mercurial-scm/hg-stable: mercurial/manifest.py annotate

annotate mercurial/manifest.py @ 52665:24ee91ba9aa8

pyupgrade: drop usage of py3 aliases for `OSError` These were different classes in py2, but now a handful of error classes are just an alias of `OSError`, like `IOError`, `EnvironmentError`, `WindowsError`, etc. This is the result of running a hacked version of `pyupgrade` 3.19.1[1] $ hg files -0 'relglob:**.py' | xargs -0 \ pyupgrade --py38-plus --keep-percent-format --keep-mock --keep-runtime-typing The hack is because it doesn't have command line switches to disable most changes, so it makes tons of unrelated changes all at once. The hack is to 1) patch `pyupgrade._main._fix_tokens()` to immediately return its content arg 2) change `pyupgrade._data.register_decorator()` to only register the function if it's from the fixer we're interested in: if func.__module__ in ( "pyupgrade._plugins.exceptions", ): FUNCS[tp].append(func) return func [1] https://github.com/asottile/pyupgrade

author	Matt Harbison <matt_harbison@yahoo.com>
date	Sun, 05 Jan 2025 21:03:17 -0500
parents	6412dcec52d3
children	5cc8deb96b48

rev	line source
1089 142b5d5ec9cc Break apart hg.py mpm@selenic.com parents: 1072 diff changeset	1 # manifest.py - manifest revision class for mercurial
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	2 #
46819 d4ba4d51f85f contributor: change mentions of mpm to olivia Rapha?l Gom?s <rgomes@octobus.net> parents: 46793 diff changeset	3 # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	4 #
8225 46293a0c7e9f updated license to be explicit about GPL version 2 Martin Geisler <mg@lazybytes.net> parents: 8209 diff changeset	5 # This software may be used and distributed according to the terms of the
10263 25e572394f5c Update license to GPLv2+ Matt Mackall <mpm@selenic.com> parents: 9420 diff changeset	6 # GNU General Public License version 2 or any later version.
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	7
51901 f4733654f144 typing: add `from __future__ import annotations` to most files Matt Harbison <matt_harbison@yahoo.com> parents: 51868 diff changeset	8 from __future__ import annotations
27502 2df7f5c09c34 manifest: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27466 diff changeset	9
2df7f5c09c34 manifest: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27466 diff changeset	10 import heapq
32569 aa333c1982ab manifest: use itertools.chain() instead of + for Python 3 compat Augie Fackler <raf@durin42.com> parents: 32568 diff changeset	11 import itertools
27502 2df7f5c09c34 manifest: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27466 diff changeset	12 import struct
52250 0851d94bfdaa manifest: delay import of `typing.ByteString` for py 3.14 support (issue6940) Matt Harbison <matt_harbison@yahoo.com> parents: 52098 diff changeset	13 import typing
38821 0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	14 import weakref
27502 2df7f5c09c34 manifest: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27466 diff changeset	15
51817 50b3ff0ec297 manifest: adds some type things for manifestdict.added Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51816 diff changeset	16 from typing import (
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	17 Callable,
51827 ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	18 Collection,
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	19 Dict,
51817 50b3ff0ec297 manifest: adds some type things for manifestdict.added Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51816 diff changeset	20 Iterable,
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	21 Iterator,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	22 List,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	23 Optional,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	24 Set,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	25 Tuple,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	26 Union,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	27 cast,
51817 50b3ff0ec297 manifest: adds some type things for manifestdict.added Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51816 diff changeset	28 )
50b3ff0ec297 manifest: adds some type things for manifestdict.added Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51816 diff changeset	29
27502 2df7f5c09c34 manifest: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27466 diff changeset	30 from .i18n import _
31536 160e7ad941e9 manifest: use node.hex instead of .encode('hex') Augie Fackler <augie@google.com> parents: 31483 diff changeset	31 from .node import (
160e7ad941e9 manifest: use node.hex instead of .encode('hex') Augie Fackler <augie@google.com> parents: 31483 diff changeset	32 bin,
160e7ad941e9 manifest: use node.hex instead of .encode('hex') Augie Fackler <augie@google.com> parents: 31483 diff changeset	33 hex,
39343 53363a8eff57 manifest: don't go through revlog to access node symbols Gregory Szorc <gregory.szorc@gmail.com> parents: 39342 diff changeset	34 nullrev,
31536 160e7ad941e9 manifest: use node.hex instead of .encode('hex') Augie Fackler <augie@google.com> parents: 31483 diff changeset	35 )
27502 2df7f5c09c34 manifest: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27466 diff changeset	36 from . import (
44164 c443b9ba6f63 py3: __repr__ needs to return str, not bytes Kyle Lippincott <spectral@google.com> parents: 43798 diff changeset	37 encoding,
27502 2df7f5c09c34 manifest: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27466 diff changeset	38 error,
44332 bbecb6d80aa7 manifest: rewrite filesnotin to not make superfluous manifest copies Augie Fackler <augie@google.com> parents: 44331 diff changeset	39 match as matchmod,
27502 2df7f5c09c34 manifest: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27466 diff changeset	40 mdiff,
43571 c21aca51b392 utils: move the `dirs` definition in pathutil (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43554 diff changeset	41 pathutil,
32411 df448de7cf3b parsers: switch to policy importer Yuya Nishihara <yuya@tcha.org> parents: 32292 diff changeset	42 policy,
38340 cf59de802883 py3: remove b'' from error message of disallowed filename Yuya Nishihara <yuya@tcha.org> parents: 37374 diff changeset	43 pycompat,
27502 2df7f5c09c34 manifest: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27466 diff changeset	44 revlog,
2df7f5c09c34 manifest: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27466 diff changeset	45 util,
2df7f5c09c34 manifest: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27466 diff changeset	46 )
42823 268662aac075 interfaces: create a new folder for interfaces and move repository.py in it Pulkit Goyal <pulkit@yandex-team.ru> parents: 42740 diff changeset	47 from .interfaces import (
268662aac075 interfaces: create a new folder for interfaces and move repository.py in it Pulkit Goyal <pulkit@yandex-team.ru> parents: 42740 diff changeset	48 repository,
38532 c82ea938efbb repository: define manifest interfaces Gregory Szorc <gregory.szorc@gmail.com> parents: 38514 diff changeset	49 )
47089 4c041c71ec01 revlog: introduce an explicit tracking of what the revlog is about Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47083 diff changeset	50 from .revlogutils import (
4c041c71ec01 revlog: introduce an explicit tracking of what the revlog is about Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47083 diff changeset	51 constants as revlog_constants,
4c041c71ec01 revlog: introduce an explicit tracking of what the revlog is about Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47083 diff changeset	52 )
79 837d473d54d5 Add basic annotation support mpm@selenic.com parents: 78 diff changeset	53
52250 0851d94bfdaa manifest: delay import of `typing.ByteString` for py 3.14 support (issue6940) Matt Harbison <matt_harbison@yahoo.com> parents: 52098 diff changeset	54 if typing.TYPE_CHECKING:
0851d94bfdaa manifest: delay import of `typing.ByteString` for py 3.14 support (issue6940) Matt Harbison <matt_harbison@yahoo.com> parents: 52098 diff changeset	55 from typing import (
0851d94bfdaa manifest: delay import of `typing.ByteString` for py 3.14 support (issue6940) Matt Harbison <matt_harbison@yahoo.com> parents: 52098 diff changeset	56 ByteString,
0851d94bfdaa manifest: delay import of `typing.ByteString` for py 3.14 support (issue6940) Matt Harbison <matt_harbison@yahoo.com> parents: 52098 diff changeset	57 )
0851d94bfdaa manifest: delay import of `typing.ByteString` for py 3.14 support (issue6940) Matt Harbison <matt_harbison@yahoo.com> parents: 52098 diff changeset	58
0851d94bfdaa manifest: delay import of `typing.ByteString` for py 3.14 support (issue6940) Matt Harbison <matt_harbison@yahoo.com> parents: 52098 diff changeset	59
43554 9f70512ae2cf cleanup: remove pointless r-prefixes on single-quoted strings Augie Fackler <augie@google.com> parents: 43346 diff changeset	60 parsers = policy.importmod('parsers')
24322 f263814c72ac manifest: add dirs() to manifestdict Drew Gottlieb <drgott@google.com> parents: 24298 diff changeset	61 propertycache = util.propertycache
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	62
42170 89c0c8edc9d4 tests: demonstrate broken manifest generation with the pure module Matt Harbison <matt_harbison@yahoo.com> parents: 41970 diff changeset	63 # Allow tests to more easily test the alternate path in manifestdict.fastdelta()
89c0c8edc9d4 tests: demonstrate broken manifest generation with the pure module Matt Harbison <matt_harbison@yahoo.com> parents: 41970 diff changeset	64 FASTDELTA_TEXTDIFF_THRESHOLD = 1000
89c0c8edc9d4 tests: demonstrate broken manifest generation with the pure module Matt Harbison <matt_harbison@yahoo.com> parents: 41970 diff changeset	65
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	66
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	67 def _parse(nodelen, data: bytes):
24524 63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	68 # This method does a little bit of excessive-looking
63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	69 # precondition checking. This is so that the behavior of this
63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	70 # class exactly matches its C counterpart to try and help
63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	71 # prevent surprise breakage for anyone that develops against
63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	72 # the pure version.
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	73 if data and data[-1:] != b'\n':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	74 raise ValueError(b'Manifest did not end in a newline.')
24524 63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	75 prev = None
63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	76 for l in data.splitlines():
63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	77 if prev is not None and prev > l:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	78 raise ValueError(b'Manifest lines not in sorted order.')
24524 63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	79 prev = l
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	80 f, n = l.split(b'\0')
44706 ce126b6bea79 manifest: remove a final 40-byte assumption from pure-python parser Augie Fackler <augie@google.com> parents: 44705 diff changeset	81 nl = len(n)
45119 19748c73c208 manifest: use the same logic for handling flags in _parse as elsewhere Joerg Sonnenberger <joerg@bec.de> parents: 45118 diff changeset	82 flags = n[-1:]
19748c73c208 manifest: use the same logic for handling flags in _parse as elsewhere Joerg Sonnenberger <joerg@bec.de> parents: 45118 diff changeset	83 if flags in _manifestflags:
19748c73c208 manifest: use the same logic for handling flags in _parse as elsewhere Joerg Sonnenberger <joerg@bec.de> parents: 45118 diff changeset	84 n = n[:-1]
19748c73c208 manifest: use the same logic for handling flags in _parse as elsewhere Joerg Sonnenberger <joerg@bec.de> parents: 45118 diff changeset	85 nl -= 1
24524 63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	86 else:
45119 19748c73c208 manifest: use the same logic for handling flags in _parse as elsewhere Joerg Sonnenberger <joerg@bec.de> parents: 45118 diff changeset	87 flags = b''
47083 12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	88 if nl != 2 * nodelen:
45119 19748c73c208 manifest: use the same logic for handling flags in _parse as elsewhere Joerg Sonnenberger <joerg@bec.de> parents: 45118 diff changeset	89 raise ValueError(b'Invalid manifest line')
19748c73c208 manifest: use the same logic for handling flags in _parse as elsewhere Joerg Sonnenberger <joerg@bec.de> parents: 45118 diff changeset	90
19748c73c208 manifest: use the same logic for handling flags in _parse as elsewhere Joerg Sonnenberger <joerg@bec.de> parents: 45118 diff changeset	91 yield f, bin(n), flags
24524 63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	92
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	93
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	94 def _text(it):
24525 e118f74d246f manifest: extract method for creating manifest text Martin von Zweigbergk <martinvonz@google.com> parents: 24524 diff changeset	95 files = []
e118f74d246f manifest: extract method for creating manifest text Martin von Zweigbergk <martinvonz@google.com> parents: 24524 diff changeset	96 lines = []
e118f74d246f manifest: extract method for creating manifest text Martin von Zweigbergk <martinvonz@google.com> parents: 24524 diff changeset	97 for f, n, fl in it:
e118f74d246f manifest: extract method for creating manifest text Martin von Zweigbergk <martinvonz@google.com> parents: 24524 diff changeset	98 files.append(f)
e118f74d246f manifest: extract method for creating manifest text Martin von Zweigbergk <martinvonz@google.com> parents: 24524 diff changeset	99 # if this is changed to support newlines in filenames,
e118f74d246f manifest: extract method for creating manifest text Martin von Zweigbergk <martinvonz@google.com> parents: 24524 diff changeset	100 # be sure to check the templates/ dir again (especially *-raw.tmpl)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	101 lines.append(b"%s\0%s%s\n" % (f, hex(n), fl))
24525 e118f74d246f manifest: extract method for creating manifest text Martin von Zweigbergk <martinvonz@google.com> parents: 24524 diff changeset	102
e118f74d246f manifest: extract method for creating manifest text Martin von Zweigbergk <martinvonz@google.com> parents: 24524 diff changeset	103 _checkforbidden(files)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	104 return b''.join(lines)
24525 e118f74d246f manifest: extract method for creating manifest text Martin von Zweigbergk <martinvonz@google.com> parents: 24524 diff changeset	105
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	106
49037 642e31cb55f0 py3: use class X: instead of class X(object): Gregory Szorc <gregory.szorc@gmail.com> parents: 49017 diff changeset	107 class lazymanifestiter:
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	108 def __init__(self, lm: '_LazyManifest') -> None:
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	109 self.pos = 0
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	110 self.lm = lm
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	111
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	112 def __iter__(self) -> 'lazymanifestiter':
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	113 return self
24223 b4df0d0c49e7 manifest: move parsing functions up in file Augie Fackler <augie@google.com> parents: 24215 diff changeset	114
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	115 def next(self) -> bytes:
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	116 try:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	117 data, pos = self.lm._get(self.pos)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	118 except IndexError:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	119 raise StopIteration
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	120 if pos == -1:
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	121 assert isinstance(data, tuple)
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	122 self.pos += 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	123 return data[0]
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	124 assert isinstance(data, bytes)
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	125 self.pos += 1
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	126 zeropos = data.find(b'\x00', pos)
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	127 return data[pos:zeropos]
24224 d71837d06597 manifest: do parsing inside manifestdict contstructor Augie Fackler <augie@google.com> parents: 24223 diff changeset	128
31373 91874c247d61 manifest: add __next__ methods for Python 3 Augie Fackler <augie@google.com> parents: 31361 diff changeset	129 __next__ = next
91874c247d61 manifest: add __next__ methods for Python 3 Augie Fackler <augie@google.com> parents: 31361 diff changeset	130
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	131
49037 642e31cb55f0 py3: use class X: instead of class X(object): Gregory Szorc <gregory.szorc@gmail.com> parents: 49017 diff changeset	132 class lazymanifestiterentries:
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	133 def __init__(self, lm: '_LazyManifest') -> None:
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	134 self.lm = lm
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	135 self.pos = 0
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	136
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	137 def __iter__(self) -> 'lazymanifestiterentries':
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	138 return self
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	139
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	140 def next(self) -> Tuple[bytes, bytes, bytes]:
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	141 try:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	142 data, pos = self.lm._get(self.pos)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	143 except IndexError:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	144 raise StopIteration
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	145 if pos == -1:
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	146 assert isinstance(data, tuple)
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	147 self.pos += 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	148 return data
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	149 assert isinstance(data, bytes)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	150 zeropos = data.find(b'\x00', pos)
45118 d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	151 nlpos = data.find(b'\n', pos)
d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	152 if zeropos == -1 or nlpos == -1 or nlpos < zeropos:
d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	153 raise error.StorageError(b'Invalid manifest line')
d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	154 flags = data[nlpos - 1 : nlpos]
d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	155 if flags in _manifestflags:
d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	156 hlen = nlpos - zeropos - 2
d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	157 else:
d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	158 hlen = nlpos - zeropos - 1
d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	159 flags = b''
47083 12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	160 if hlen != 2 * self.lm._nodelen:
45118 d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	161 raise error.StorageError(b'Invalid manifest line')
d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	162 hashval = unhexlify(
d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	163 data, self.lm.extrainfo[self.pos], zeropos + 1, hlen
d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	164 )
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	165 self.pos += 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	166 return (data[pos:zeropos], hashval, flags)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	167
31373 91874c247d61 manifest: add __next__ methods for Python 3 Augie Fackler <augie@google.com> parents: 31361 diff changeset	168 __next__ = next
91874c247d61 manifest: add __next__ methods for Python 3 Augie Fackler <augie@google.com> parents: 31361 diff changeset	169
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	170
51816 2f88df88f5b9 manifest: type and fix unhexlify Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51812 diff changeset	171 def unhexlify(data: bytes, extra: int, pos, length: int):
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	172 s = bin(data[pos : pos + length])
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	173 if extra:
51816 2f88df88f5b9 manifest: type and fix unhexlify Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51812 diff changeset	174 s += bytes([extra & 0xFF])
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	175 return s
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	176
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	177
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	178 def _cmp(a, b):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	179 return (a > b) - (a < b)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	180
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	181
45118 d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	182 _manifestflags = {b'', b'l', b't', b'x'}
d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	183
d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	184
51820 3e9a660b074a manifest: expose a version of the Class without interface decorator Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51818 diff changeset	185 class _LazyManifest:
42172 c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	186 """A pure python manifest backed by a byte string. It is supplimented with
c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	187 internal lists as it is modified, until it is compacted back to a pure byte
c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	188 string.
c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	189
c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	190 ``data`` is the initial manifest data.
c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	191
c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	192 ``positions`` is a list of offsets, one per manifest entry. Positive
c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	193 values are offsets into ``data``, negative values are offsets into the
c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	194 ``extradata`` list. When an entry is removed, its entry is dropped from
c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	195 ``positions``. The values are encoded such that when walking the list and
c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	196 indexing into ``data`` or ``extradata`` as appropriate, the entries are
c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	197 sorted by filename.
c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	198
c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	199 ``extradata`` is a list of (key, hash, flags) for entries that were added or
c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	200 modified since the manifest was created or compacted.
c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	201 """
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	202
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	203 def __init__(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	204 self,
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	205 nodelen: int,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	206 data: bytes,
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	207 positions=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	208 extrainfo=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	209 extradata=None,
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	210 hasremovals: bool = False,
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	211 ):
47083 12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	212 self._nodelen = nodelen
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	213 if positions is None:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	214 self.positions = self.findlines(data)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	215 self.extrainfo = [0] * len(self.positions)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	216 self.data = data
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	217 self.extradata = []
42171 0546ead39a7e manifest: avoid corruption by dropping removed files with pure (issue5801) Matt Harbison <matt_harbison@yahoo.com> parents: 42170 diff changeset	218 self.hasremovals = False
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	219 else:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	220 self.positions = positions[:]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	221 self.extrainfo = extrainfo[:]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	222 self.extradata = extradata[:]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	223 self.data = data
42171 0546ead39a7e manifest: avoid corruption by dropping removed files with pure (issue5801) Matt Harbison <matt_harbison@yahoo.com> parents: 42170 diff changeset	224 self.hasremovals = hasremovals
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	225
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	226 def findlines(self, data: bytes) -> List[int]:
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	227 if not data:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	228 return []
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	229 pos = data.find(b"\n")
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	230 if pos == -1 or data[-1:] != b'\n':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	231 raise ValueError(b"Manifest did not end in a newline.")
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	232 positions = [0]
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	233 prev = data[: data.find(b'\x00')]
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	234 while pos < len(data) - 1 and pos != -1:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	235 positions.append(pos + 1)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	236 nexts = data[pos + 1 : data.find(b'\x00', pos + 1)]
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	237 if nexts < prev:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	238 raise ValueError(b"Manifest lines not in sorted order.")
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	239 prev = nexts
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	240 pos = data.find(b"\n", pos + 1)
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	241 return positions
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	242
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	243 def _get(
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	244 self, index: int
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	245 ) -> Tuple[Union[bytes, Tuple[bytes, bytes, bytes]], int]:
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	246 # get the position encoded in pos:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	247 # positive number is an index in 'data'
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	248 # negative number is in extrapieces
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	249 pos = self.positions[index]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	250 if pos >= 0:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	251 return self.data, pos
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	252 return self.extradata[-pos - 1], -1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	253
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	254 def _getkey(self, pos) -> bytes:
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	255 if pos >= 0:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	256 return self.data[pos : self.data.find(b'\x00', pos + 1)]
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	257 return self.extradata[-pos - 1][0]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	258
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	259 def bsearch(self, key: bytes) -> int:
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	260 first = 0
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	261 last = len(self.positions) - 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	262
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	263 while first <= last:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	264 midpoint = (first + last) // 2
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	265 nextpos = self.positions[midpoint]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	266 candidate = self._getkey(nextpos)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	267 r = _cmp(key, candidate)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	268 if r == 0:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	269 return midpoint
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	270 else:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	271 if r < 0:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	272 last = midpoint - 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	273 else:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	274 first = midpoint + 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	275 return -1
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	276
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	277 def bsearch2(self, key: bytes) -> Tuple[int, bool]:
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	278 # same as the above, but will always return the position
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	279 # done for performance reasons
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	280 first = 0
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	281 last = len(self.positions) - 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	282
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	283 while first <= last:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	284 midpoint = (first + last) // 2
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	285 nextpos = self.positions[midpoint]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	286 candidate = self._getkey(nextpos)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	287 r = _cmp(key, candidate)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	288 if r == 0:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	289 return (midpoint, True)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	290 else:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	291 if r < 0:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	292 last = midpoint - 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	293 else:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	294 first = midpoint + 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	295 return (first, False)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	296
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	297 def __contains__(self, key: bytes) -> bool:
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	298 return self.bsearch(key) != -1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	299
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	300 def __getitem__(self, key: bytes) -> Tuple[bytes, bytes]:
31376 ef50b491c17d manifest: ensure paths are bytes (not str) in pure parser Augie Fackler <augie@google.com> parents: 31375 diff changeset	301 if not isinstance(key, bytes):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	302 raise TypeError(b"getitem: manifest keys must be a bytes.")
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	303 needle = self.bsearch(key)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	304 if needle == -1:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	305 raise KeyError
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	306 data, pos = self._get(needle)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	307 if pos == -1:
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	308 assert isinstance(data, tuple)
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	309 return (data[1], data[2])
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	310
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	311 assert isinstance(data, bytes)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	312 zeropos = data.find(b'\x00', pos)
44706 ce126b6bea79 manifest: remove a final 40-byte assumption from pure-python parser Augie Fackler <augie@google.com> parents: 44705 diff changeset	313 nlpos = data.find(b'\n', zeropos)
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	314 assert 0 <= needle <= len(self.positions)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	315 assert len(self.extrainfo) == len(self.positions)
45118 d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	316 if zeropos == -1 or nlpos == -1 or nlpos < zeropos:
d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	317 raise error.StorageError(b'Invalid manifest line')
44706 ce126b6bea79 manifest: remove a final 40-byte assumption from pure-python parser Augie Fackler <augie@google.com> parents: 44705 diff changeset	318 hlen = nlpos - zeropos - 1
45118 d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	319 flags = data[nlpos - 1 : nlpos]
d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	320 if flags in _manifestflags:
44706 ce126b6bea79 manifest: remove a final 40-byte assumption from pure-python parser Augie Fackler <augie@google.com> parents: 44705 diff changeset	321 hlen -= 1
45118 d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	322 else:
d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	323 flags = b''
47083 12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	324 if hlen != 2 * self._nodelen:
45118 d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	325 raise error.StorageError(b'Invalid manifest line')
44706 ce126b6bea79 manifest: remove a final 40-byte assumption from pure-python parser Augie Fackler <augie@google.com> parents: 44705 diff changeset	326 hashval = unhexlify(data, self.extrainfo[needle], zeropos + 1, hlen)
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	327 return (hashval, flags)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	328
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	329 def __delitem__(self, key: bytes) -> None:
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	330 needle, found = self.bsearch2(key)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	331 if not found:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	332 raise KeyError
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	333 cur = self.positions[needle]
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	334 self.positions = self.positions[:needle] + self.positions[needle + 1 :]
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	335 self.extrainfo = self.extrainfo[:needle] + self.extrainfo[needle + 1 :]
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	336 if cur >= 0:
42172 c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	337 # This does NOT unsort the list as far as the search functions are
c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	338 # concerned, as they only examine lines mapped by self.positions.
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	339 self.data = self.data[:cur] + b'\x00' + self.data[cur + 1 :]
42171 0546ead39a7e manifest: avoid corruption by dropping removed files with pure (issue5801) Matt Harbison <matt_harbison@yahoo.com> parents: 42170 diff changeset	340 self.hasremovals = True
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	341
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	342 def __setitem__(self, key: bytes, value: Tuple[bytes, bytes]):
31537 326bca5477d0 manifest: refer to bytestrings as bytes, not str Augie Fackler <augie@google.com> parents: 31536 diff changeset	343 if not isinstance(key, bytes):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	344 raise TypeError(b"setitem: manifest keys must be a byte string.")
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	345 if not isinstance(value, tuple) or len(value) != 2:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	346 raise TypeError(
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	347 b"Manifest values must be a tuple of (node, flags)."
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	348 )
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	349 hashval = value[0]
45253 ff59af8395a5 manifest: kill one more instance of the old merge hash hack Joerg Sonnenberger <joerg@bec.de> parents: 45119 diff changeset	350 if not isinstance(hashval, bytes) or len(hashval) not in (20, 32):
44705 75f1197db884 manifest: fix yet another 20-byte-hash assumption Augie Fackler <augie@google.com> parents: 44704 diff changeset	351 raise TypeError(b"node must be a 20-byte or 32-byte byte string")
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	352 flags = value[1]
31537 326bca5477d0 manifest: refer to bytestrings as bytes, not str Augie Fackler <augie@google.com> parents: 31536 diff changeset	353 if not isinstance(flags, bytes) or len(flags) > 1:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	354 raise TypeError(b"flags must a 0 or 1 byte string, got %r", flags)
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	355 needle, found = self.bsearch2(key)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	356 if found:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	357 # put the item
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	358 pos = self.positions[needle]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	359 if pos < 0:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	360 self.extradata[-pos - 1] = (key, hashval, value[1])
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	361 else:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	362 # just don't bother
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	363 self.extradata.append((key, hashval, value[1]))
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	364 self.positions[needle] = -len(self.extradata)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	365 else:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	366 # not found, put it in with extra positions
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	367 self.extradata.append((key, hashval, value[1]))
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	368 self.positions = (
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	369 self.positions[:needle]
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	370 + [-len(self.extradata)]
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	371 + self.positions[needle:]
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	372 )
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	373 self.extrainfo = (
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	374 self.extrainfo[:needle] + [0] + self.extrainfo[needle:]
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	375 )
24298 49cd847fd69a lazymanifest: make __iter__ generate filenames, not 3-tuples Martin von Zweigbergk <martinvonz@google.com> parents: 24297 diff changeset	376
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	377 def copy(self) -> '_LazyManifest':
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	378 # XXX call _compact like in C?
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	379 return _lazymanifest(
47083 12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	380 self._nodelen,
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	381 self.data,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	382 self.positions,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	383 self.extrainfo,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	384 self.extradata,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	385 self.hasremovals,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	386 )
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	387
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	388 def _compact(self) -> None:
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	389 # hopefully not called TOO often
42171 0546ead39a7e manifest: avoid corruption by dropping removed files with pure (issue5801) Matt Harbison <matt_harbison@yahoo.com> parents: 42170 diff changeset	390 if len(self.extradata) == 0 and not self.hasremovals:
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	391 return
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	392 l = []
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	393 i = 0
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	394 offset = 0
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	395 self.extrainfo = [0] * len(self.positions)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	396 while i < len(self.positions):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	397 if self.positions[i] >= 0:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	398 cur = self.positions[i]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	399 last_cut = cur
42172 c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	400
c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	401 # Collect all contiguous entries in the buffer at the current
c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	402 # offset, breaking out only for added/modified items held in
c3484ddbdb96 manifest: add some documentation to _lazymanifest python code Matt Harbison <matt_harbison@yahoo.com> parents: 42171 diff changeset	403 # extradata, or a deleted line prior to the next position.
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	404 while True:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	405 self.positions[i] = offset
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	406 i += 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	407 if i == len(self.positions) or self.positions[i] < 0:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	408 break
42171 0546ead39a7e manifest: avoid corruption by dropping removed files with pure (issue5801) Matt Harbison <matt_harbison@yahoo.com> parents: 42170 diff changeset	409
0546ead39a7e manifest: avoid corruption by dropping removed files with pure (issue5801) Matt Harbison <matt_harbison@yahoo.com> parents: 42170 diff changeset	410 # A removed file has no positions[] entry, but does have an
0546ead39a7e manifest: avoid corruption by dropping removed files with pure (issue5801) Matt Harbison <matt_harbison@yahoo.com> parents: 42170 diff changeset	411 # overwritten first byte. Break out and find the end of the
0546ead39a7e manifest: avoid corruption by dropping removed files with pure (issue5801) Matt Harbison <matt_harbison@yahoo.com> parents: 42170 diff changeset	412 # current good entry/entries if there is a removed file
0546ead39a7e manifest: avoid corruption by dropping removed files with pure (issue5801) Matt Harbison <matt_harbison@yahoo.com> parents: 42170 diff changeset	413 # before the next position.
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	414 if (
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	415 self.hasremovals
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	416 and self.data.find(b'\n\x00', cur, self.positions[i])
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	417 != -1
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	418 ):
42171 0546ead39a7e manifest: avoid corruption by dropping removed files with pure (issue5801) Matt Harbison <matt_harbison@yahoo.com> parents: 42170 diff changeset	419 break
0546ead39a7e manifest: avoid corruption by dropping removed files with pure (issue5801) Matt Harbison <matt_harbison@yahoo.com> parents: 42170 diff changeset	420
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	421 offset += self.positions[i] - cur
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	422 cur = self.positions[i]
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	423 end_cut = self.data.find(b'\n', cur)
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	424 if end_cut != -1:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	425 end_cut += 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	426 offset += end_cut - cur
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	427 l.append(self.data[last_cut:end_cut])
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	428 else:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	429 while i < len(self.positions) and self.positions[i] < 0:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	430 cur = self.positions[i]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	431 t = self.extradata[-cur - 1]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	432 l.append(self._pack(t))
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	433 self.positions[i] = offset
44704 0415a566742a manifest: fix another pure-parsing 20-byte assumption Augie Fackler <augie@google.com> parents: 44703 diff changeset	434 # Hashes are either 20 bytes (old sha1s) or 32
0415a566742a manifest: fix another pure-parsing 20-byte assumption Augie Fackler <augie@google.com> parents: 44703 diff changeset	435 # bytes (new non-sha1).
0415a566742a manifest: fix another pure-parsing 20-byte assumption Augie Fackler <augie@google.com> parents: 44703 diff changeset	436 hlen = 20
0415a566742a manifest: fix another pure-parsing 20-byte assumption Augie Fackler <augie@google.com> parents: 44703 diff changeset	437 if len(t[1]) > 25:
0415a566742a manifest: fix another pure-parsing 20-byte assumption Augie Fackler <augie@google.com> parents: 44703 diff changeset	438 hlen = 32
0415a566742a manifest: fix another pure-parsing 20-byte assumption Augie Fackler <augie@google.com> parents: 44703 diff changeset	439 if len(t[1]) > hlen:
0415a566742a manifest: fix another pure-parsing 20-byte assumption Augie Fackler <augie@google.com> parents: 44703 diff changeset	440 self.extrainfo[i] = ord(t[1][hlen + 1])
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	441 offset += len(l[-1])
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	442 i += 1
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	443 self.data = b''.join(l)
42171 0546ead39a7e manifest: avoid corruption by dropping removed files with pure (issue5801) Matt Harbison <matt_harbison@yahoo.com> parents: 42170 diff changeset	444 self.hasremovals = False
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	445 self.extradata = []
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	446
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	447 def _pack(self, d: Tuple[bytes, bytes, bytes]) -> bytes:
44701 ecbba7b2e444 manifest: remove a 20-byte-hash assumption from pure manifest parsing Augie Fackler <augie@google.com> parents: 44666 diff changeset	448 n = d[1]
45118 d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	449 assert len(n) in (20, 32)
44701 ecbba7b2e444 manifest: remove a 20-byte-hash assumption from pure manifest parsing Augie Fackler <augie@google.com> parents: 44666 diff changeset	450 return d[0] + b'\x00' + hex(n) + d[2] + b'\n'
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	451
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	452 def text(self) -> ByteString:
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	453 self._compact()
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	454 return self.data
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	455
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	456 def diff(
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	457 self, m2: '_LazyManifest', clean: bool = False
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	458 ) -> Dict[
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	459 bytes,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	460 Optional[
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	461 Tuple[Tuple[Optional[bytes], bytes], Tuple[Optional[bytes], bytes]]
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	462 ],
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	463 ]:
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	464 '''Finds changes between the current manifest and m2.'''
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	465 # XXX think whether efficiency matters here
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	466 diff = {}
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	467
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	468 for fn, e1, flags in self.iterentries():
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	469 if fn not in m2:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	470 diff[fn] = (e1, flags), (None, b'')
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	471 else:
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	472 e2 = m2[fn]
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	473 if (e1, flags) != e2:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	474 diff[fn] = (e1, flags), e2
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	475 elif clean:
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	476 diff[fn] = None
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	477
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	478 for fn, e2, flags in m2.iterentries():
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	479 if fn not in self:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	480 diff[fn] = (None, b''), (e2, flags)
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	481
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	482 return diff
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	483
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	484 def iterentries(self) -> lazymanifestiterentries:
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	485 return lazymanifestiterentries(self)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	486
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	487 def iterkeys(self) -> lazymanifestiter:
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	488 return lazymanifestiter(self)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	489
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	490 def __iter__(self) -> lazymanifestiter:
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	491 return lazymanifestiter(self)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	492
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	493 def __len__(self) -> int:
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	494 return len(self.positions)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	495
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	496 def filtercopy(self, filterfn: Callable[[bytes], bool]) -> '_LazyManifest':
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	497 # XXX should be optimized
47083 12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	498 c = _lazymanifest(self._nodelen, b'')
24298 49cd847fd69a lazymanifest: make __iter__ generate filenames, not 3-tuples Martin von Zweigbergk <martinvonz@google.com> parents: 24297 diff changeset	499 for f, n, fl in self.iterentries():
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	500 if filterfn(f):
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	501 c[f] = n, fl
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	502 return c
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	503
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	504
24226 b992769dd1be manifest: use custom C implementation of lazymanifest Augie Fackler <augie@google.com> parents: 24225 diff changeset	505 try:
b992769dd1be manifest: use custom C implementation of lazymanifest Augie Fackler <augie@google.com> parents: 24225 diff changeset	506 _lazymanifest = parsers.lazymanifest
b992769dd1be manifest: use custom C implementation of lazymanifest Augie Fackler <augie@google.com> parents: 24225 diff changeset	507 except AttributeError:
51820 3e9a660b074a manifest: expose a version of the Class without interface decorator Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51818 diff changeset	508 _lazymanifest = _LazyManifest
24226 b992769dd1be manifest: use custom C implementation of lazymanifest Augie Fackler <augie@google.com> parents: 24225 diff changeset	509
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	510
52524 6412dcec52d3 manifest: subclass the new `repository.imanifestdict` Protocol class Matt Harbison <matt_harbison@yahoo.com> parents: 52513 diff changeset	511 class manifestdict(repository.imanifestdict):
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	512 def __init__(self, nodelen: int, data: ByteString = b''):
47083 12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	513 self._nodelen = nodelen
12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	514 self._lm = _lazymanifest(nodelen, data)
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	515
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	516 def __getitem__(self, key: bytes) -> bytes:
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	517 return self._lm[key][0]
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	518
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	519 def find(self, key: bytes) -> Tuple[bytes, bytes]:
24277 22d560fe1516 manifest: don't let find() look inside manifestdict Martin von Zweigbergk <martinvonz@google.com> parents: 24226 diff changeset	520 return self._lm[key]
22d560fe1516 manifest: don't let find() look inside manifestdict Martin von Zweigbergk <martinvonz@google.com> parents: 24226 diff changeset	521
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	522 def __len__(self) -> int:
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	523 return len(self._lm)
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	524
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	525 def __nonzero__(self) -> bool:
30341 b19291e5d506 manifest: add __nonzero__ method Durham Goode <durham@fb.com> parents: 30309 diff changeset	526 # nonzero is covered by the __len__ function, but implementing it here
b19291e5d506 manifest: add __nonzero__ method Durham Goode <durham@fb.com> parents: 30309 diff changeset	527 # makes it easier for extensions to override.
b19291e5d506 manifest: add __nonzero__ method Durham Goode <durham@fb.com> parents: 30309 diff changeset	528 return len(self._lm) != 0
b19291e5d506 manifest: add __nonzero__ method Durham Goode <durham@fb.com> parents: 30309 diff changeset	529
31483 413b44003462 py3: add __bool__ to every class defining __nonzero__ Gregory Szorc <gregory.szorc@gmail.com> parents: 31376 diff changeset	530 __bool__ = __nonzero__
413b44003462 py3: add __bool__ to every class defining __nonzero__ Gregory Szorc <gregory.szorc@gmail.com> parents: 31376 diff changeset	531
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	532 def set(self, key: bytes, node: bytes, flags: bytes) -> None:
51812 421c9b3f2f4e commit: set whole manifest entries at once (node with its associated flags) Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51052 diff changeset	533 self._lm[key] = node, flags
421c9b3f2f4e commit: set whole manifest entries at once (node with its associated flags) Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51052 diff changeset	534
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	535 def __setitem__(self, key: bytes, node: bytes) -> None:
44304 dbbae122f5e4 manifest: remove optional default= argument on flags(path) Augie Fackler <augie@google.com> parents: 43798 diff changeset	536 self._lm[key] = node, self.flags(key)
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	537
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	538 def __contains__(self, key: bytes) -> bool:
34352 05167447f90d py3: return False early while checking whether None is a key in lazymanifest Pulkit Goyal <7895pulkit@gmail.com> parents: 34303 diff changeset	539 if key is None:
05167447f90d py3: return False early while checking whether None is a key in lazymanifest Pulkit Goyal <7895pulkit@gmail.com> parents: 34303 diff changeset	540 return False
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	541 return key in self._lm
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	542
51844 62b25293b620 typing: correct a type hint in `mercurial.manifest` Matt Harbison <matt_harbison@yahoo.com> parents: 51840 diff changeset	543 def __delitem__(self, key: bytes) -> None:
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	544 del self._lm[key]
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	545
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	546 def __iter__(self) -> Iterator[bytes]:
24298 49cd847fd69a lazymanifest: make __iter__ generate filenames, not 3-tuples Martin von Zweigbergk <martinvonz@google.com> parents: 24297 diff changeset	547 return self._lm.__iter__()
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	548
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	549 def iterkeys(self) -> Iterator[bytes]:
24295 2b7ab29627fd lazymanifest: add iterkeys() method Martin von Zweigbergk <martinvonz@google.com> parents: 24292 diff changeset	550 return self._lm.iterkeys()
2b7ab29627fd lazymanifest: add iterkeys() method Martin von Zweigbergk <martinvonz@google.com> parents: 24292 diff changeset	551
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	552 def keys(self) -> List[bytes]:
24295 2b7ab29627fd lazymanifest: add iterkeys() method Martin von Zweigbergk <martinvonz@google.com> parents: 24292 diff changeset	553 return list(self.iterkeys())
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	554
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	555 def filesnotin(self, m2, match=None) -> Set[bytes]:
24184 cd66080ef6d4 copies: move code into new manifestdict.filesnotin() method Martin von Zweigbergk <martinvonz@google.com> parents: 24147 diff changeset	556 '''Set of files in this manifest that are not in the other'''
44332 bbecb6d80aa7 manifest: rewrite filesnotin to not make superfluous manifest copies Augie Fackler <augie@google.com> parents: 44331 diff changeset	557 if match is not None:
bbecb6d80aa7 manifest: rewrite filesnotin to not make superfluous manifest copies Augie Fackler <augie@google.com> parents: 44331 diff changeset	558 match = matchmod.badmatch(match, lambda path, msg: None)
bbecb6d80aa7 manifest: rewrite filesnotin to not make superfluous manifest copies Augie Fackler <augie@google.com> parents: 44331 diff changeset	559 sm2 = set(m2.walk(match))
bbecb6d80aa7 manifest: rewrite filesnotin to not make superfluous manifest copies Augie Fackler <augie@google.com> parents: 44331 diff changeset	560 return {f for f in self.walk(match) if f not in sm2}
bbecb6d80aa7 manifest: rewrite filesnotin to not make superfluous manifest copies Augie Fackler <augie@google.com> parents: 44331 diff changeset	561 return {f for f in self if f not in m2}
24184 cd66080ef6d4 copies: move code into new manifestdict.filesnotin() method Martin von Zweigbergk <martinvonz@google.com> parents: 24147 diff changeset	562
24322 f263814c72ac manifest: add dirs() to manifestdict Drew Gottlieb <drgott@google.com> parents: 24298 diff changeset	563 @propertycache
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	564 def _dirs(self) -> pathutil.dirs:
43571 c21aca51b392 utils: move the `dirs` definition in pathutil (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43554 diff changeset	565 return pathutil.dirs(self)
24322 f263814c72ac manifest: add dirs() to manifestdict Drew Gottlieb <drgott@google.com> parents: 24298 diff changeset	566
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	567 def dirs(self) -> pathutil.dirs:
24322 f263814c72ac manifest: add dirs() to manifestdict Drew Gottlieb <drgott@google.com> parents: 24298 diff changeset	568 return self._dirs
f263814c72ac manifest: add dirs() to manifestdict Drew Gottlieb <drgott@google.com> parents: 24298 diff changeset	569
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	570 def hasdir(self, dir: bytes) -> bool:
24324 149cc171e4a0 manifest: add manifestdict.hasdir() method Drew Gottlieb <drgott@google.com> parents: 24322 diff changeset	571 return dir in self._dirs
149cc171e4a0 manifest: add manifestdict.hasdir() method Drew Gottlieb <drgott@google.com> parents: 24322 diff changeset	572
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	573 def _filesfastpath(self, match: matchmod.basematcher) -> bool:
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	574 """Checks whether we can correctly and quickly iterate over matcher
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	575 files instead of over manifest files."""
24685 b3d78d82d84c manifestdict: extract condition for _intersectfiles() and use for walk() Martin von Zweigbergk <martinvonz@google.com> parents: 24684 diff changeset	576 files = match.files()
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	577 return len(files) < 100 and (
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	578 match.isexact()
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	579 or (match.prefix() and all(fn in self for fn in files))
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	580 )
24685 b3d78d82d84c manifestdict: extract condition for _intersectfiles() and use for walk() Martin von Zweigbergk <martinvonz@google.com> parents: 24684 diff changeset	581
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	582 def walk(self, match: matchmod.basematcher) -> Iterator[bytes]:
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	583 """Generates matching file names.
24646 5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	584
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	585 Equivalent to manifest.matches(match).iterkeys(), but without creating
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	586 an entirely new manifest.
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	587
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	588 It also reports nonexistent files by marking them bad with match.bad().
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	589 """
24683 4eaea0ed8dc1 manifest.walk: special-case match.always() for speed Martin von Zweigbergk <martinvonz@google.com> parents: 24682 diff changeset	590 if match.always():
4eaea0ed8dc1 manifest.walk: special-case match.always() for speed Martin von Zweigbergk <martinvonz@google.com> parents: 24682 diff changeset	591 for f in iter(self):
4eaea0ed8dc1 manifest.walk: special-case match.always() for speed Martin von Zweigbergk <martinvonz@google.com> parents: 24682 diff changeset	592 yield f
4eaea0ed8dc1 manifest.walk: special-case match.always() for speed Martin von Zweigbergk <martinvonz@google.com> parents: 24682 diff changeset	593 return
4eaea0ed8dc1 manifest.walk: special-case match.always() for speed Martin von Zweigbergk <martinvonz@google.com> parents: 24682 diff changeset	594
24646 5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	595 fset = set(match.files())
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	596
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	597 # avoid the entire walk if we're only looking for specific files
24685 b3d78d82d84c manifestdict: extract condition for _intersectfiles() and use for walk() Martin von Zweigbergk <martinvonz@google.com> parents: 24684 diff changeset	598 if self._filesfastpath(match):
24667 19c5b0913960 manifest.walk: join nested if-conditions Martin von Zweigbergk <martinvonz@google.com> parents: 24666 diff changeset	599 for fn in sorted(fset):
44316 48a1a974a92c manifest: fix _very_ subtle bug with exact matchers passed to walk() Augie Fackler <augie@google.com> parents: 44309 diff changeset	600 if fn in self:
48a1a974a92c manifest: fix _very_ subtle bug with exact matchers passed to walk() Augie Fackler <augie@google.com> parents: 44309 diff changeset	601 yield fn
24682 aef3d1469773 manifest.walk: use return instead of StopIteration in generator Martin von Zweigbergk <martinvonz@google.com> parents: 24670 diff changeset	602 return
24646 5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	603
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	604 for fn in self:
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	605 if fn in fset:
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	606 # specified pattern is the exact name
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	607 fset.remove(fn)
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	608 if match(fn):
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	609 yield fn
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	610
42363 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41970 diff changeset	611 # for dirstate.walk, files=[''] means "walk the whole tree".
24646 5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	612 # follow that here, too
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	613 fset.discard(b'')
24646 5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	614
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	615 for fn in sorted(fset):
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	616 if not self.hasdir(fn):
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	617 match.bad(fn, None)
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	618
52091 35400ce47b64 manifest: drop the CamelCase name for `manifest.manifestdict` Matt Harbison <matt_harbison@yahoo.com> parents: 51909 diff changeset	619 def _matches(self, match: matchmod.basematcher) -> 'manifestdict':
23305 0cc283f44655 manifest: add matches() method Martin von Zweigbergk <martinvonz@google.com> parents: 22966 diff changeset	620 '''generate a new manifest filtered by the match argument'''
0cc283f44655 manifest: add matches() method Martin von Zweigbergk <martinvonz@google.com> parents: 22966 diff changeset	621 if match.always():
0cc283f44655 manifest: add matches() method Martin von Zweigbergk <martinvonz@google.com> parents: 22966 diff changeset	622 return self.copy()
0cc283f44655 manifest: add matches() method Martin von Zweigbergk <martinvonz@google.com> parents: 22966 diff changeset	623
24685 b3d78d82d84c manifestdict: extract condition for _intersectfiles() and use for walk() Martin von Zweigbergk <martinvonz@google.com> parents: 24684 diff changeset	624 if self._filesfastpath(match):
47083 12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	625 m = manifestdict(self._nodelen)
24666 3092885b5b32 manifestdict: inline _intersectfiles() Martin von Zweigbergk <martinvonz@google.com> parents: 24665 diff changeset	626 lm = self._lm
3092885b5b32 manifestdict: inline _intersectfiles() Martin von Zweigbergk <martinvonz@google.com> parents: 24665 diff changeset	627 for fn in match.files():
3092885b5b32 manifestdict: inline _intersectfiles() Martin von Zweigbergk <martinvonz@google.com> parents: 24665 diff changeset	628 if fn in lm:
3092885b5b32 manifestdict: inline _intersectfiles() Martin von Zweigbergk <martinvonz@google.com> parents: 24665 diff changeset	629 m._lm[fn] = lm[fn]
3092885b5b32 manifestdict: inline _intersectfiles() Martin von Zweigbergk <martinvonz@google.com> parents: 24665 diff changeset	630 return m
23305 0cc283f44655 manifest: add matches() method Martin von Zweigbergk <martinvonz@google.com> parents: 22966 diff changeset	631
47083 12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	632 m = manifestdict(self._nodelen)
24664 ea4a7c8909ae manifestdict.matches: avoid name 'lm' for a not-lazymanifest Martin von Zweigbergk <martinvonz@google.com> parents: 24647 diff changeset	633 m._lm = self._lm.filtercopy(match)
ea4a7c8909ae manifestdict.matches: avoid name 'lm' for a not-lazymanifest Martin von Zweigbergk <martinvonz@google.com> parents: 24647 diff changeset	634 return m
23305 0cc283f44655 manifest: add matches() method Martin von Zweigbergk <martinvonz@google.com> parents: 22966 diff changeset	635
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	636 def diff(
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	637 self,
52091 35400ce47b64 manifest: drop the CamelCase name for `manifest.manifestdict` Matt Harbison <matt_harbison@yahoo.com> parents: 51909 diff changeset	638 m2: 'manifestdict',
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	639 match: Optional[matchmod.basematcher] = None,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	640 clean: bool = False,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	641 ) -> Dict[
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	642 bytes,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	643 Optional[
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	644 Tuple[Tuple[Optional[bytes], bytes], Tuple[Optional[bytes], bytes]]
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	645 ],
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	646 ]:
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	647 """Finds changes between the current manifest and m2.
23756 829f640b5540 manifest: add optional recording of clean entries to diff Augie Fackler <augie@google.com> parents: 23602 diff changeset	648
829f640b5540 manifest: add optional recording of clean entries to diff Augie Fackler <augie@google.com> parents: 23602 diff changeset	649 Args:
829f640b5540 manifest: add optional recording of clean entries to diff Augie Fackler <augie@google.com> parents: 23602 diff changeset	650 m2: the manifest to which this manifest should be compared.
829f640b5540 manifest: add optional recording of clean entries to diff Augie Fackler <augie@google.com> parents: 23602 diff changeset	651 clean: if true, include files unchanged between these manifests
829f640b5540 manifest: add optional recording of clean entries to diff Augie Fackler <augie@google.com> parents: 23602 diff changeset	652 with a None value in the returned dictionary.
829f640b5540 manifest: add optional recording of clean entries to diff Augie Fackler <augie@google.com> parents: 23602 diff changeset	653
829f640b5540 manifest: add optional recording of clean entries to diff Augie Fackler <augie@google.com> parents: 23602 diff changeset	654 The result is returned as a dict with filename as key and
829f640b5540 manifest: add optional recording of clean entries to diff Augie Fackler <augie@google.com> parents: 23602 diff changeset	655 values of the form ((n1,fl1),(n2,fl2)), where n1/n2 is the
829f640b5540 manifest: add optional recording of clean entries to diff Augie Fackler <augie@google.com> parents: 23602 diff changeset	656 nodeid in the current/other manifest and fl1/fl2 is the flag
829f640b5540 manifest: add optional recording of clean entries to diff Augie Fackler <augie@google.com> parents: 23602 diff changeset	657 in the current/other manifest. Where the file does not exist,
829f640b5540 manifest: add optional recording of clean entries to diff Augie Fackler <augie@google.com> parents: 23602 diff changeset	658 the nodeid will be None and the flags will be the empty
829f640b5540 manifest: add optional recording of clean entries to diff Augie Fackler <augie@google.com> parents: 23602 diff changeset	659 string.
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	660 """
31265 959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	661 if match:
44386 0bf3b5e80d30 manifest: move matches method to be outside the interface Augie Fackler <augie@google.com> parents: 44332 diff changeset	662 m1 = self._matches(match)
0bf3b5e80d30 manifest: move matches method to be outside the interface Augie Fackler <augie@google.com> parents: 44332 diff changeset	663 m2 = m2._matches(match)
31265 959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	664 return m1.diff(m2, clean=clean)
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	665 return self._lm.diff(m2._lm, clean)
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	666
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	667 def setflag(self, key: bytes, flag: bytes) -> None:
45118 d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	668 if flag not in _manifestflags:
d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	669 raise TypeError(b"Invalid manifest flag set.")
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	670 self._lm[key] = self[key], flag
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	671
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	672 def get(self, key: bytes, default=None) -> Optional[bytes]:
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	673 try:
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	674 return self._lm[key][0]
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	675 except KeyError:
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	676 return default
22965 b697fa74b475 manifest: for diff(), only iterate over files, not flags Martin von Zweigbergk <martinvonz@gmail.com> parents: 22964 diff changeset	677
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	678 def flags(self, key: bytes) -> bytes:
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	679 try:
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	680 return self._lm[key][1]
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	681 except KeyError:
44304 dbbae122f5e4 manifest: remove optional default= argument on flags(path) Augie Fackler <augie@google.com> parents: 43798 diff changeset	682 return b''
22965 b697fa74b475 manifest: for diff(), only iterate over files, not flags Martin von Zweigbergk <martinvonz@gmail.com> parents: 22964 diff changeset	683
52091 35400ce47b64 manifest: drop the CamelCase name for `manifest.manifestdict` Matt Harbison <matt_harbison@yahoo.com> parents: 51909 diff changeset	684 def copy(self) -> 'manifestdict':
47083 12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	685 c = manifestdict(self._nodelen)
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	686 c._lm = self._lm.copy()
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	687 return c
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	688
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	689 def items(self) -> Iterator[Tuple[bytes, bytes]]:
24298 49cd847fd69a lazymanifest: make __iter__ generate filenames, not 3-tuples Martin von Zweigbergk <martinvonz@google.com> parents: 24297 diff changeset	690 return (x[:2] for x in self._lm.iterentries())
2831 0b50a580be36 Add manifestflags class Matt Mackall <mpm@selenic.com> parents: 2470 diff changeset	691
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	692 def iteritems(self) -> Iterator[Tuple[bytes, bytes]]:
38657 28c9d67d88ab manifest: just duplicate the definition of items as iteritems Augie Fackler <augie@google.com> parents: 38557 diff changeset	693 return (x[:2] for x in self._lm.iterentries())
32583 b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias Augie Fackler <raf@durin42.com> parents: 32569 diff changeset	694
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	695 def iterentries(self) -> Iterator[Tuple[bytes, bytes, bytes]]:
28203 7297e9e13a8a verify: check directory manifests Martin von Zweigbergk <martinvonz@google.com> parents: 27502 diff changeset	696 return self._lm.iterentries()
7297e9e13a8a verify: check directory manifests Martin von Zweigbergk <martinvonz@google.com> parents: 27502 diff changeset	697
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	698 def text(self) -> ByteString:
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	699 # most likely uses native version
0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	700 return self._lm.text()
22408 dc97e04c12ad manifest: move checkforbidden to module-level Augie Fackler <raf@durin42.com> parents: 21879 diff changeset	701
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	702 def fastdelta(
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	703 self, base: ByteString, changes: Iterable[Tuple[bytes, bool]]
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	704 ) -> Tuple[ByteString, ByteString]:
31790 6bfea18df609 manifest: update comment to be about bytearray Martin von Zweigbergk <martinvonz@google.com> parents: 31655 diff changeset	705 """Given a base manifest text as a bytearray and a list of changes
22931 48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	706 relative to that text, compute a delta that can be used by revlog.
48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	707 """
48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	708 delta = []
48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	709 dstart = None
48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	710 dend = None
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	711 dline = [b""]
22931 48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	712 start = 0
48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	713 # zero copy representation of base as a buffer
48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	714 addbuf = util.buffer(base)
48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	715
26871 1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	716 changes = list(changes)
42170 89c0c8edc9d4 tests: demonstrate broken manifest generation with the pure module Matt Harbison <matt_harbison@yahoo.com> parents: 41970 diff changeset	717 if len(changes) < FASTDELTA_TEXTDIFF_THRESHOLD:
26871 1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	718 # start with a readonly loop that finds the offset of
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	719 # each line and creates the deltas
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	720 for f, todelete in changes:
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	721 # bs will either be the index of the item or the insert point
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	722 start, end = _msearch(addbuf, f, start)
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	723 if not todelete:
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	724 h, fl = self._lm[f]
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	725 l = b"%s\0%s%s\n" % (f, hex(h), fl)
26871 1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	726 else:
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	727 if start == end:
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	728 # item we want to delete was not found, error out
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	729 raise AssertionError(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	730 _(b"failed to remove %s from manifest") % f
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	731 )
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	732 l = b""
26871 1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	733 if dstart is not None and dstart <= start and dend >= start:
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	734 if dend < end:
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	735 dend = end
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	736 if l:
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	737 dline.append(l)
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	738 else:
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	739 if dstart is not None:
51821 897972398e61 manifest: use tuple for `delta` in `fastdelta` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51820 diff changeset	740 delta.append((dstart, dend, b"".join(dline)))
26871 1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	741 dstart = start
22931 48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	742 dend = end
26871 1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	743 dline = [l]
22931 48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	744
26871 1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	745 if dstart is not None:
51821 897972398e61 manifest: use tuple for `delta` in `fastdelta` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51820 diff changeset	746 delta.append((dstart, dend, b"".join(dline)))
26871 1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	747 # apply the delta to the base, and get a delta for addrevision
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	748 deltatext, arraytext = _addlistdelta(base, delta)
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	749 else:
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	750 # For large changes, it's much cheaper to just build the text and
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	751 # diff it.
31355 2a18e9e6ca43 py3: use bytearray() instead of array('c', ...) constructions Augie Fackler <augie@google.com> parents: 31303 diff changeset	752 arraytext = bytearray(self.text())
2a18e9e6ca43 py3: use bytearray() instead of array('c', ...) constructions Augie Fackler <augie@google.com> parents: 31303 diff changeset	753 deltatext = mdiff.textdiff(
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	754 util.buffer(base), util.buffer(arraytext)
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	755 )
26871 1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	756
22931 48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	757 return arraytext, deltatext
48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	758
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	759
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	760 def _msearch(
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	761 m: ByteString, s: bytes, lo: int = 0, hi: Optional[int] = None
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	762 ) -> Tuple[int, int]:
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	763 """return a tuple (start, end) that says where to find s within m.
22930 1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	764
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	765 If the string is found m[start:end] are the line containing
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	766 that string. If start == end the string was not found and
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	767 they indicate the proper sorted insertion point.
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	768 """
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	769
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	770 def advance(i: int, c: bytes):
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	771 while i < lenm and m[i : i + 1] != c:
22930 1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	772 i += 1
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	773 return i
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	774
22930 1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	775 if not s:
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	776 return (lo, lo)
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	777 lenm = len(m)
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	778 if not hi:
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	779 hi = lenm
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	780 while lo < hi:
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	781 mid = (lo + hi) // 2
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	782 start = mid
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	783 while start > 0 and m[start - 1 : start] != b'\n':
22930 1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	784 start -= 1
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	785 end = advance(start, b'\0')
31655 23391acfc421 py3: fix manifestdict.fastdelta() to be compatible with memoryview Yuya Nishihara <yuya@tcha.org> parents: 31537 diff changeset	786 if bytes(m[start:end]) < s:
22930 1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	787 # we know that after the null there are 40 bytes of sha1
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	788 # this translates to the bisect lo = mid + 1
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	789 lo = advance(end + 40, b'\n') + 1
22930 1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	790 else:
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	791 # this translates to the bisect hi = mid
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	792 hi = start
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	793 end = advance(lo, b'\0')
22930 1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	794 found = m[lo:end]
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	795 if s == found:
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	796 # we know that after the null there are 40 bytes of sha1
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	797 end = advance(end + 40, b'\n')
22930 1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	798 return (lo, end + 1)
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	799 else:
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	800 return (lo, lo)
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	801
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	802
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	803 def _checkforbidden(l: Iterable[bytes]) -> None:
22408 dc97e04c12ad manifest: move checkforbidden to module-level Augie Fackler <raf@durin42.com> parents: 21879 diff changeset	804 """Check filenames for illegal characters."""
dc97e04c12ad manifest: move checkforbidden to module-level Augie Fackler <raf@durin42.com> parents: 21879 diff changeset	805 for f in l:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	806 if b'\n' in f or b'\r' in f:
39793 b63dee7bd0d9 global: replace most uses of RevlogError with StorageError (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 39779 diff changeset	807 raise error.StorageError(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	808 _(b"'\\n' and '\\r' disallowed in filenames: %r")
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	809 % pycompat.bytestr(f)
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	810 )
22408 dc97e04c12ad manifest: move checkforbidden to module-level Augie Fackler <raf@durin42.com> parents: 21879 diff changeset	811
dc97e04c12ad manifest: move checkforbidden to module-level Augie Fackler <raf@durin42.com> parents: 21879 diff changeset	812
22409 8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	813 # apply the changes collected during the bisect loop to our addlist
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	814 # return a delta suitable for addrevision
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	815 def _addlistdelta(
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	816 addlist: ByteString,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	817 x: Iterable[Tuple[int, int, bytes]],
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	818 ) -> Tuple[bytes, ByteString]:
22409 8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	819 # for large addlist arrays, building a new array is cheaper
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	820 # than repeatedly modifying the existing one
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	821 currentposition = 0
31355 2a18e9e6ca43 py3: use bytearray() instead of array('c', ...) constructions Augie Fackler <augie@google.com> parents: 31303 diff changeset	822 newaddlist = bytearray()
22409 8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	823
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	824 for start, end, content in x:
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	825 newaddlist += addlist[currentposition:start]
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	826 if content:
31355 2a18e9e6ca43 py3: use bytearray() instead of array('c', ...) constructions Augie Fackler <augie@google.com> parents: 31303 diff changeset	827 newaddlist += bytearray(content)
22409 8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	828
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	829 currentposition = end
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	830
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	831 newaddlist += addlist[currentposition:]
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	832
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	833 deltatext = b"".join(
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	834 struct.pack(b">lll", start, end, len(content)) + content
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	835 for start, end, content in x
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	836 )
22409 8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	837 return deltatext, newaddlist
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	838
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	839
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	840 def _splittopdir(f: bytes) -> Tuple[bytes, bytes]:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	841 if b'/' in f:
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	842 dir, subpath = f.split(b'/', 1)
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	843 return dir + b'/', subpath
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	844 else:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	845 return b'', f
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	846
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	847
26402 05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	848 _noop = lambda s: None
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	849
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	850
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	851 class treemanifest: # (repository.imanifestdict)
51868 0338fb200a30 typing: lock in new pytype gains from making revlog related classes typeable Matt Harbison <matt_harbison@yahoo.com> parents: 51865 diff changeset	852 _dir: bytes
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	853 _dirs: Dict[bytes, 'treemanifest']
51868 0338fb200a30 typing: lock in new pytype gains from making revlog related classes typeable Matt Harbison <matt_harbison@yahoo.com> parents: 51865 diff changeset	854 _dirty: bool
0338fb200a30 typing: lock in new pytype gains from making revlog related classes typeable Matt Harbison <matt_harbison@yahoo.com> parents: 51865 diff changeset	855 _files: Dict[bytes, bytes]
0338fb200a30 typing: lock in new pytype gains from making revlog related classes typeable Matt Harbison <matt_harbison@yahoo.com> parents: 51865 diff changeset	856 _flags: Dict[bytes, bytes]
0338fb200a30 typing: lock in new pytype gains from making revlog related classes typeable Matt Harbison <matt_harbison@yahoo.com> parents: 51865 diff changeset	857
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	858 def __init__(self, nodeconstants, dir: bytes = b'', text: bytes = b''):
24403 0e23faa1511c treemanifest: store directory path in treemanifest nodes Martin von Zweigbergk <martinvonz@google.com> parents: 24402 diff changeset	859 self._dir = dir
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	860 self.nodeconstants = nodeconstants
47055 d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	861 self._node = self.nodeconstants.nullid
47083 12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	862 self._nodelen = self.nodeconstants.nodelen
26402 05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	863 self._loadfunc = _noop
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	864 self._copyfunc = _noop
25220 f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	865 self._dirty = False
51868 0338fb200a30 typing: lock in new pytype gains from making revlog related classes typeable Matt Harbison <matt_harbison@yahoo.com> parents: 51865 diff changeset	866 self._dirs = {}
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	867 self._lazydirs: Dict[
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	868 bytes,
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	869 Tuple[bytes, Callable[[bytes, bytes], 'treemanifest'], bool],
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	870 ] = {}
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	871 # Using _lazymanifest here is a little slower than plain old dicts
51868 0338fb200a30 typing: lock in new pytype gains from making revlog related classes typeable Matt Harbison <matt_harbison@yahoo.com> parents: 51865 diff changeset	872 self._files = {}
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	873 self._flags = {}
25220 f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	874 if text:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	875
25220 f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	876 def readsubtree(subdir, subm):
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	877 raise AssertionError(
43117 8ff1ecfadcd1 cleanup: join string literals that are already on one line Martin von Zweigbergk <martinvonz@google.com> parents: 43106 diff changeset	878 b'treemanifest constructor only accepts flat manifests'
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	879 )
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	880
25220 f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	881 self.parse(text, readsubtree)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	882 self._dirty = True # Mark flat manifest dirty after parsing
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	883
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	884 def _subpath(self, path: bytes) -> bytes:
24403 0e23faa1511c treemanifest: store directory path in treemanifest nodes Martin von Zweigbergk <martinvonz@google.com> parents: 24402 diff changeset	885 return self._dir + path
0e23faa1511c treemanifest: store directory path in treemanifest nodes Martin von Zweigbergk <martinvonz@google.com> parents: 24402 diff changeset	886
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	887 def _loadalllazy(self) -> None:
40040 a0c18b271ea1 treemanifests: store whether a lazydirs entry needs copied after materializing spectral <spectral@google.com> parents: 40039 diff changeset	888 selfdirs = self._dirs
46096 93e09d370003 treemanifest: stop storing full path for each item in manifest._lazydirs Kyle Lippincott <spectral@google.com> parents: 45957 diff changeset	889 subpath = self._subpath
49017 3d35e7483602 manifest: remove pycompat.iteritems() Gregory Szorc <gregory.szorc@gmail.com> parents: 49004 diff changeset	890 for d, (node, readsubtree, docopy) in self._lazydirs.items():
40040 a0c18b271ea1 treemanifests: store whether a lazydirs entry needs copied after materializing spectral <spectral@google.com> parents: 40039 diff changeset	891 if docopy:
46096 93e09d370003 treemanifest: stop storing full path for each item in manifest._lazydirs Kyle Lippincott <spectral@google.com> parents: 45957 diff changeset	892 selfdirs[d] = readsubtree(subpath(d), node).copy()
40040 a0c18b271ea1 treemanifests: store whether a lazydirs entry needs copied after materializing spectral <spectral@google.com> parents: 40039 diff changeset	893 else:
46096 93e09d370003 treemanifest: stop storing full path for each item in manifest._lazydirs Kyle Lippincott <spectral@google.com> parents: 45957 diff changeset	894 selfdirs[d] = readsubtree(subpath(d), node)
51822 3be39e36732a manifest: clear `_lazydirs` in place in `_loadalllazy` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51821 diff changeset	895 self._lazydirs.clear()
39532 93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	896
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	897 def _loadlazy(self, d: bytes) -> None:
39982 da0319e024c0 treemanifests: make _loadlazy tolerate item not on _lazydirs spectral <spectral@google.com> parents: 39874 diff changeset	898 v = self._lazydirs.get(d)
51823 1c28d9fdcd08 manifest: use explicit None checking in `_loadlazy` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51822 diff changeset	899 if v is not None:
46096 93e09d370003 treemanifest: stop storing full path for each item in manifest._lazydirs Kyle Lippincott <spectral@google.com> parents: 45957 diff changeset	900 node, readsubtree, docopy = v
40040 a0c18b271ea1 treemanifests: store whether a lazydirs entry needs copied after materializing spectral <spectral@google.com> parents: 40039 diff changeset	901 if docopy:
46096 93e09d370003 treemanifest: stop storing full path for each item in manifest._lazydirs Kyle Lippincott <spectral@google.com> parents: 45957 diff changeset	902 self._dirs[d] = readsubtree(self._subpath(d), node).copy()
40040 a0c18b271ea1 treemanifests: store whether a lazydirs entry needs copied after materializing spectral <spectral@google.com> parents: 40039 diff changeset	903 else:
46096 93e09d370003 treemanifest: stop storing full path for each item in manifest._lazydirs Kyle Lippincott <spectral@google.com> parents: 45957 diff changeset	904 self._dirs[d] = readsubtree(self._subpath(d), node)
39982 da0319e024c0 treemanifests: make _loadlazy tolerate item not on _lazydirs spectral <spectral@google.com> parents: 39874 diff changeset	905 del self._lazydirs[d]
39532 93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	906
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	907 def _loadchildrensetlazy(
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	908 self, visit: Union[Set[bytes], bytes]
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	909 ) -> Optional[Set[bytes]]:
39538 154e4f84b51c treemanifest: use visitchildrenset when filtering a manifest to a matcher Kyle Lippincott <spectral@google.com> parents: 39535 diff changeset	910 if not visit:
154e4f84b51c treemanifest: use visitchildrenset when filtering a manifest to a matcher Kyle Lippincott <spectral@google.com> parents: 39535 diff changeset	911 return None
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	912 if visit == b'all' or visit == b'this':
39538 154e4f84b51c treemanifest: use visitchildrenset when filtering a manifest to a matcher Kyle Lippincott <spectral@google.com> parents: 39535 diff changeset	913 self._loadalllazy()
154e4f84b51c treemanifest: use visitchildrenset when filtering a manifest to a matcher Kyle Lippincott <spectral@google.com> parents: 39535 diff changeset	914 return None
154e4f84b51c treemanifest: use visitchildrenset when filtering a manifest to a matcher Kyle Lippincott <spectral@google.com> parents: 39535 diff changeset	915
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	916 visit = cast(Set[bytes], visit)
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	917
39983 19103e68a698 treemanifests: make _loadchildrensetlazy just call _loadlazy spectral <spectral@google.com> parents: 39982 diff changeset	918 loadlazy = self._loadlazy
39538 154e4f84b51c treemanifest: use visitchildrenset when filtering a manifest to a matcher Kyle Lippincott <spectral@google.com> parents: 39535 diff changeset	919 for k in visit:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	920 loadlazy(k + b'/')
39538 154e4f84b51c treemanifest: use visitchildrenset when filtering a manifest to a matcher Kyle Lippincott <spectral@google.com> parents: 39535 diff changeset	921 return visit
154e4f84b51c treemanifest: use visitchildrenset when filtering a manifest to a matcher Kyle Lippincott <spectral@google.com> parents: 39535 diff changeset	922
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	923 def _loaddifflazy(self, t1: 'treemanifest', t2: 'treemanifest'):
40039 906c95073ff7 treemanifests: extract _loaddifflazy from _diff, use in _filesnotin spectral <spectral@google.com> parents: 39988 diff changeset	924 """load items in t1 and t2 if they're needed for diffing.
906c95073ff7 treemanifests: extract _loaddifflazy from _diff, use in _filesnotin spectral <spectral@google.com> parents: 39988 diff changeset	925
906c95073ff7 treemanifests: extract _loaddifflazy from _diff, use in _filesnotin spectral <spectral@google.com> parents: 39988 diff changeset	926 The criteria currently is:
906c95073ff7 treemanifests: extract _loaddifflazy from _diff, use in _filesnotin spectral <spectral@google.com> parents: 39988 diff changeset	927 - if it's not present in _lazydirs in either t1 or t2, load it in the
906c95073ff7 treemanifests: extract _loaddifflazy from _diff, use in _filesnotin spectral <spectral@google.com> parents: 39988 diff changeset	928 other (it may already be loaded or it may not exist, doesn't matter)
906c95073ff7 treemanifests: extract _loaddifflazy from _diff, use in _filesnotin spectral <spectral@google.com> parents: 39988 diff changeset	929 - if it's present in _lazydirs in both, compare the nodeid; if it
906c95073ff7 treemanifests: extract _loaddifflazy from _diff, use in _filesnotin spectral <spectral@google.com> parents: 39988 diff changeset	930 differs, load it in both
906c95073ff7 treemanifests: extract _loaddifflazy from _diff, use in _filesnotin spectral <spectral@google.com> parents: 39988 diff changeset	931 """
906c95073ff7 treemanifests: extract _loaddifflazy from _diff, use in _filesnotin spectral <spectral@google.com> parents: 39988 diff changeset	932 toloadlazy = []
49004 f254fc73d956 global: bulk replace simple pycompat.iteritems(x) with x.items() Gregory Szorc <gregory.szorc@gmail.com> parents: 48966 diff changeset	933 for d, v1 in t1._lazydirs.items():
40039 906c95073ff7 treemanifests: extract _loaddifflazy from _diff, use in _filesnotin spectral <spectral@google.com> parents: 39988 diff changeset	934 v2 = t2._lazydirs.get(d)
51824 8e1b28687704 manifest: use explicit None checking in `_loaddifflazy` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51823 diff changeset	935 if v2 is None or v2[0] != v1[0]:
40039 906c95073ff7 treemanifests: extract _loaddifflazy from _diff, use in _filesnotin spectral <spectral@google.com> parents: 39988 diff changeset	936 toloadlazy.append(d)
49004 f254fc73d956 global: bulk replace simple pycompat.iteritems(x) with x.items() Gregory Szorc <gregory.szorc@gmail.com> parents: 48966 diff changeset	937 for d, v1 in t2._lazydirs.items():
40039 906c95073ff7 treemanifests: extract _loaddifflazy from _diff, use in _filesnotin spectral <spectral@google.com> parents: 39988 diff changeset	938 if d not in t1._lazydirs:
906c95073ff7 treemanifests: extract _loaddifflazy from _diff, use in _filesnotin spectral <spectral@google.com> parents: 39988 diff changeset	939 toloadlazy.append(d)
906c95073ff7 treemanifests: extract _loaddifflazy from _diff, use in _filesnotin spectral <spectral@google.com> parents: 39988 diff changeset	940
906c95073ff7 treemanifests: extract _loaddifflazy from _diff, use in _filesnotin spectral <spectral@google.com> parents: 39988 diff changeset	941 for d in toloadlazy:
906c95073ff7 treemanifests: extract _loaddifflazy from _diff, use in _filesnotin spectral <spectral@google.com> parents: 39988 diff changeset	942 t1._loadlazy(d)
906c95073ff7 treemanifests: extract _loaddifflazy from _diff, use in _filesnotin spectral <spectral@google.com> parents: 39988 diff changeset	943 t2._loadlazy(d)
906c95073ff7 treemanifests: extract _loaddifflazy from _diff, use in _filesnotin spectral <spectral@google.com> parents: 39988 diff changeset	944
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	945 def __len__(self) -> int:
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	946 self._load()
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	947 size = len(self._files)
39532 93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	948 self._loadalllazy()
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	949 for m in self._dirs.values():
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	950 size += m.__len__()
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	951 return size
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	952
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	953 def __nonzero__(self) -> bool:
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	954 # Faster than "__len__() != 0" since it avoids loading sub-manifests
36212 b42c47b8c9d4 treemanifest: add an optimized __nonzero__() Martin von Zweigbergk <martinvonz@google.com> parents: 36133 diff changeset	955 return not self._isempty()
b42c47b8c9d4 treemanifest: add an optimized __nonzero__() Martin von Zweigbergk <martinvonz@google.com> parents: 36133 diff changeset	956
b42c47b8c9d4 treemanifest: add an optimized __nonzero__() Martin von Zweigbergk <martinvonz@google.com> parents: 36133 diff changeset	957 __bool__ = __nonzero__
b42c47b8c9d4 treemanifest: add an optimized __nonzero__() Martin von Zweigbergk <martinvonz@google.com> parents: 36133 diff changeset	958
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	959 def _isempty(self) -> bool:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	960 self._load() # for consistency; already loaded by all callers
39533 079d7bfa463d treemanifest: attempt to avoid loading all lazily-loaded subdirs in _isempty Kyle Lippincott <spectral@google.com> parents: 39532 diff changeset	961 # See if we can skip loading everything.
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	962 if self._files or (
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	963 self._dirs and any(not m._isempty() for m in self._dirs.values())
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	964 ):
39533 079d7bfa463d treemanifest: attempt to avoid loading all lazily-loaded subdirs in _isempty Kyle Lippincott <spectral@google.com> parents: 39532 diff changeset	965 return False
39532 93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	966 self._loadalllazy()
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	967 return not self._dirs or all(m._isempty() for m in self._dirs.values())
24551 4fdf5eac5b39 treemanifest: add treemanifest._isempty() Drew Gottlieb <drgott@google.com> parents: 24550 diff changeset	968
44164 c443b9ba6f63 py3: __repr__ needs to return str, not bytes Kyle Lippincott <spectral@google.com> parents: 43798 diff changeset	969 @encoding.strmethod
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	970 def __repr__(self) -> bytes:
43346 6ada8a274b9c formatting: run black version 19.10b0 on the codebase Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43117 diff changeset	971 return (
44164 c443b9ba6f63 py3: __repr__ needs to return str, not bytes Kyle Lippincott <spectral@google.com> parents: 43798 diff changeset	972 b'<treemanifest dir=%s, node=%s, loaded=%r, dirty=%r at 0x%x>'
43346 6ada8a274b9c formatting: run black version 19.10b0 on the codebase Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43117 diff changeset	973 % (
6ada8a274b9c formatting: run black version 19.10b0 on the codebase Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43117 diff changeset	974 self._dir,
6ada8a274b9c formatting: run black version 19.10b0 on the codebase Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43117 diff changeset	975 hex(self._node),
6ada8a274b9c formatting: run black version 19.10b0 on the codebase Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43117 diff changeset	976 bool(self._loadfunc is _noop),
6ada8a274b9c formatting: run black version 19.10b0 on the codebase Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43117 diff changeset	977 self._dirty,
6ada8a274b9c formatting: run black version 19.10b0 on the codebase Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43117 diff changeset	978 id(self),
6ada8a274b9c formatting: run black version 19.10b0 on the codebase Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43117 diff changeset	979 )
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	980 )
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	981
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	982 def dir(self) -> bytes:
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	983 """The directory that this tree manifest represents, including a
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	984 trailing '/'. Empty string for the repo root directory."""
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	985 return self._dir
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	986
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	987 def node(self) -> bytes:
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	988 """This node of this instance. nullid for unsaved instances. Should
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	989 be updated when the instance is read or written from a revlog.
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	990 """
25220 f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	991 assert not self._dirty
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	992 return self._node
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	993
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	994 def setnode(self, node: bytes) -> None:
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	995 self._node = node
25220 f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	996 self._dirty = False
24403 0e23faa1511c treemanifest: store directory path in treemanifest nodes Martin von Zweigbergk <martinvonz@google.com> parents: 24402 diff changeset	997
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	998 def iterentries(
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	999 self,
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	1000 ) -> Iterator[Tuple[bytes, Union[bytes, 'treemanifest'], bytes]]:
28206 8ab91d9290ce treemanifest: implement iterentries() Martin von Zweigbergk <martinvonz@google.com> parents: 28203 diff changeset	1001 self._load()
39532 93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	1002 self._loadalllazy()
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1003 for p, n in sorted(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1004 itertools.chain(self._dirs.items(), self._files.items())
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1005 ):
28206 8ab91d9290ce treemanifest: implement iterentries() Martin von Zweigbergk <martinvonz@google.com> parents: 28203 diff changeset	1006 if p in self._files:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1007 yield self._subpath(p), n, self._flags.get(p, b'')
28206 8ab91d9290ce treemanifest: implement iterentries() Martin von Zweigbergk <martinvonz@google.com> parents: 28203 diff changeset	1008 else:
8ab91d9290ce treemanifest: implement iterentries() Martin von Zweigbergk <martinvonz@google.com> parents: 28203 diff changeset	1009 for x in n.iterentries():
8ab91d9290ce treemanifest: implement iterentries() Martin von Zweigbergk <martinvonz@google.com> parents: 28203 diff changeset	1010 yield x
8ab91d9290ce treemanifest: implement iterentries() Martin von Zweigbergk <martinvonz@google.com> parents: 28203 diff changeset	1011
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	1012 def items(self) -> Iterator[Tuple[bytes, Union[bytes, 'treemanifest']]]:
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1013 self._load()
39532 93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	1014 self._loadalllazy()
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1015 for p, n in sorted(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1016 itertools.chain(self._dirs.items(), self._files.items())
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1017 ):
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1018 if p in self._files:
24403 0e23faa1511c treemanifest: store directory path in treemanifest nodes Martin von Zweigbergk <martinvonz@google.com> parents: 24402 diff changeset	1019 yield self._subpath(p), n
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1020 else:
49004 f254fc73d956 global: bulk replace simple pycompat.iteritems(x) with x.items() Gregory Szorc <gregory.szorc@gmail.com> parents: 48966 diff changeset	1021 for f, sn in n.items():
24403 0e23faa1511c treemanifest: store directory path in treemanifest nodes Martin von Zweigbergk <martinvonz@google.com> parents: 24402 diff changeset	1022 yield f, sn
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1023
32583 b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias Augie Fackler <raf@durin42.com> parents: 32569 diff changeset	1024 iteritems = items
b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias Augie Fackler <raf@durin42.com> parents: 32569 diff changeset	1025
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1026 def iterkeys(self) -> Iterator[bytes]:
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1027 self._load()
39532 93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	1028 self._loadalllazy()
32569 aa333c1982ab manifest: use itertools.chain() instead of + for Python 3 compat Augie Fackler <raf@durin42.com> parents: 32568 diff changeset	1029 for p in sorted(itertools.chain(self._dirs, self._files)):
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1030 if p in self._files:
24403 0e23faa1511c treemanifest: store directory path in treemanifest nodes Martin von Zweigbergk <martinvonz@google.com> parents: 24402 diff changeset	1031 yield self._subpath(p)
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1032 else:
35586 fbf1a5d680ea py3: don't use dict.iterkeys() Pulkit Goyal <7895pulkit@gmail.com> parents: 34352 diff changeset	1033 for f in self._dirs[p]:
24403 0e23faa1511c treemanifest: store directory path in treemanifest nodes Martin von Zweigbergk <martinvonz@google.com> parents: 24402 diff changeset	1034 yield f
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1035
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1036 def keys(self) -> List[bytes]:
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1037 return list(self.iterkeys())
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1038
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1039 def __iter__(self) -> Iterator[bytes]:
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1040 return self.iterkeys()
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1041
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1042 def __contains__(self, f: bytes) -> bool:
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1043 if f is None:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1044 return False
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1045 self._load()
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1046 dir, subpath = _splittopdir(f)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1047 if dir:
39984 3cacb74c3a22 treemanifests: skip extraneous check for item before calling _loadlazy spectral <spectral@google.com> parents: 39983 diff changeset	1048 self._loadlazy(dir)
39532 93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	1049
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1050 if dir not in self._dirs:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1051 return False
39532 93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	1052
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1053 return self._dirs[dir].__contains__(subpath)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1054 else:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1055 return f in self._files
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1056
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1057 def get(self, f: bytes, default: Optional[bytes] = None) -> Optional[bytes]:
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1058 self._load()
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1059 dir, subpath = _splittopdir(f)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1060 if dir:
39984 3cacb74c3a22 treemanifests: skip extraneous check for item before calling _loadlazy spectral <spectral@google.com> parents: 39983 diff changeset	1061 self._loadlazy(dir)
39532 93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	1062
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1063 if dir not in self._dirs:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1064 return default
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1065 return self._dirs[dir].get(subpath, default)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1066 else:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1067 return self._files.get(f, default)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1068
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1069 def __getitem__(self, f: bytes) -> bytes:
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1070 self._load()
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1071 dir, subpath = _splittopdir(f)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1072 if dir:
39984 3cacb74c3a22 treemanifests: skip extraneous check for item before calling _loadlazy spectral <spectral@google.com> parents: 39983 diff changeset	1073 self._loadlazy(dir)
39532 93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	1074
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1075 return self._dirs[dir].__getitem__(subpath)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1076 else:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1077 return self._files[f]
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1078
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1079 def flags(self, f: bytes) -> bytes:
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1080 self._load()
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1081 dir, subpath = _splittopdir(f)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1082 if dir:
39984 3cacb74c3a22 treemanifests: skip extraneous check for item before calling _loadlazy spectral <spectral@google.com> parents: 39983 diff changeset	1083 self._loadlazy(dir)
39532 93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	1084
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1085 if dir not in self._dirs:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1086 return b''
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1087 return self._dirs[dir].flags(subpath)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1088 else:
39532 93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	1089 if f in self._lazydirs or f in self._dirs:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1090 return b''
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1091 return self._flags.get(f, b'')
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1092
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1093 def find(self, f: bytes) -> Tuple[bytes, bytes]:
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1094 self._load()
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1095 dir, subpath = _splittopdir(f)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1096 if dir:
39984 3cacb74c3a22 treemanifests: skip extraneous check for item before calling _loadlazy spectral <spectral@google.com> parents: 39983 diff changeset	1097 self._loadlazy(dir)
39532 93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	1098
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1099 return self._dirs[dir].find(subpath)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1100 else:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1101 return self._files[f], self._flags.get(f, b'')
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1102
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1103 def __delitem__(self, f: bytes) -> None:
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1104 self._load()
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1105 dir, subpath = _splittopdir(f)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1106 if dir:
39984 3cacb74c3a22 treemanifests: skip extraneous check for item before calling _loadlazy spectral <spectral@google.com> parents: 39983 diff changeset	1107 self._loadlazy(dir)
39532 93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	1108
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1109 self._dirs[dir].__delitem__(subpath)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1110 # If the directory is now empty, remove it
24551 4fdf5eac5b39 treemanifest: add treemanifest._isempty() Drew Gottlieb <drgott@google.com> parents: 24550 diff changeset	1111 if self._dirs[dir]._isempty():
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1112 del self._dirs[dir]
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1113 else:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1114 del self._files[f]
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1115 if f in self._flags:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1116 del self._flags[f]
25220 f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1117 self._dirty = True
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1118
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1119 def set(self, f: bytes, node: bytes, flags: bytes) -> None:
51812 421c9b3f2f4e commit: set whole manifest entries at once (node with its associated flags) Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51052 diff changeset	1120 """Set both the node and the flags for path f."""
421c9b3f2f4e commit: set whole manifest entries at once (node with its associated flags) Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51052 diff changeset	1121 assert node is not None
421c9b3f2f4e commit: set whole manifest entries at once (node with its associated flags) Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51052 diff changeset	1122 if flags not in _manifestflags:
421c9b3f2f4e commit: set whole manifest entries at once (node with its associated flags) Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51052 diff changeset	1123 raise TypeError(b"Invalid manifest flag set.")
421c9b3f2f4e commit: set whole manifest entries at once (node with its associated flags) Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51052 diff changeset	1124 self._load()
421c9b3f2f4e commit: set whole manifest entries at once (node with its associated flags) Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51052 diff changeset	1125 dir, subpath = _splittopdir(f)
421c9b3f2f4e commit: set whole manifest entries at once (node with its associated flags) Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51052 diff changeset	1126 if dir:
421c9b3f2f4e commit: set whole manifest entries at once (node with its associated flags) Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51052 diff changeset	1127 self._loadlazy(dir)
421c9b3f2f4e commit: set whole manifest entries at once (node with its associated flags) Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51052 diff changeset	1128 if dir not in self._dirs:
421c9b3f2f4e commit: set whole manifest entries at once (node with its associated flags) Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51052 diff changeset	1129 self._dirs[dir] = treemanifest(
421c9b3f2f4e commit: set whole manifest entries at once (node with its associated flags) Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51052 diff changeset	1130 self.nodeconstants, self._subpath(dir)
421c9b3f2f4e commit: set whole manifest entries at once (node with its associated flags) Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51052 diff changeset	1131 )
421c9b3f2f4e commit: set whole manifest entries at once (node with its associated flags) Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51052 diff changeset	1132 self._dirs[dir].set(subpath, node, flags)
421c9b3f2f4e commit: set whole manifest entries at once (node with its associated flags) Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51052 diff changeset	1133 else:
421c9b3f2f4e commit: set whole manifest entries at once (node with its associated flags) Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51052 diff changeset	1134 assert len(node) in (20, 32)
421c9b3f2f4e commit: set whole manifest entries at once (node with its associated flags) Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51052 diff changeset	1135 self._files[f] = node
421c9b3f2f4e commit: set whole manifest entries at once (node with its associated flags) Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51052 diff changeset	1136 self._flags[f] = flags
421c9b3f2f4e commit: set whole manifest entries at once (node with its associated flags) Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51052 diff changeset	1137 self._dirty = True
421c9b3f2f4e commit: set whole manifest entries at once (node with its associated flags) Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51052 diff changeset	1138
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1139 def __setitem__(self, f: bytes, n: bytes) -> None:
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1140 assert n is not None
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1141 self._load()
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1142 dir, subpath = _splittopdir(f)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1143 if dir:
39984 3cacb74c3a22 treemanifests: skip extraneous check for item before calling _loadlazy spectral <spectral@google.com> parents: 39983 diff changeset	1144 self._loadlazy(dir)
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1145 if dir not in self._dirs:
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	1146 self._dirs[dir] = treemanifest(
6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	1147 self.nodeconstants, self._subpath(dir)
6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	1148 )
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1149 self._dirs[dir].__setitem__(subpath, n)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1150 else:
44703 0e99b876966a manifest: teach treemanifest about long hashes Augie Fackler <augie@google.com> parents: 44701 diff changeset	1151 # manifest nodes are either 20 bytes or 32 bytes,
45118 d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	1152 # depending on the hash in use. Assert this as historically
d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	1153 # sometimes extra bytes were added.
d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	1154 assert len(n) in (20, 32)
d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	1155 self._files[f] = n
25220 f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1156 self._dirty = True
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1157
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1158 def _load(self) -> None:
26402 05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1159 if self._loadfunc is not _noop:
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1160 lf, self._loadfunc = self._loadfunc, _noop
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1161 lf(self)
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1162 elif self._copyfunc is not _noop:
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1163 cf, self._copyfunc = self._copyfunc, _noop
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1164 cf(self)
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1165
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1166 def setflag(self, f: bytes, flags: bytes) -> None:
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1167 """Set the flags (symlink, executable) for path f."""
45118 d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	1168 if flags not in _manifestflags:
d0ef8c1dddd4 manifest: tigher manifest parsing and flag use Joerg Sonnenberger <joerg@bec.de> parents: 45067 diff changeset	1169 raise TypeError(b"Invalid manifest flag set.")
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1170 self._load()
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1171 dir, subpath = _splittopdir(f)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1172 if dir:
39984 3cacb74c3a22 treemanifests: skip extraneous check for item before calling _loadlazy spectral <spectral@google.com> parents: 39983 diff changeset	1173 self._loadlazy(dir)
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1174 if dir not in self._dirs:
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	1175 self._dirs[dir] = treemanifest(
6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	1176 self.nodeconstants, self._subpath(dir)
6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	1177 )
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1178 self._dirs[dir].setflag(subpath, flags)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1179 else:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1180 self._flags[f] = flags
25220 f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1181 self._dirty = True
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1182
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	1183 def copy(self) -> 'treemanifest':
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	1184 copy = treemanifest(self.nodeconstants, self._dir)
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1185 copy._node = self._node
25220 f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1186 copy._dirty = self._dirty
26402 05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1187 if self._copyfunc is _noop:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1188
26402 05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1189 def _copyfunc(s):
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1190 self._load()
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1191 s._lazydirs = {
49004 f254fc73d956 global: bulk replace simple pycompat.iteritems(x) with x.items() Gregory Szorc <gregory.szorc@gmail.com> parents: 48966 diff changeset	1192 d: (n, r, True) for d, (n, r, c) in self._lazydirs.items()
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1193 }
39532 93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	1194 sdirs = s._dirs
49004 f254fc73d956 global: bulk replace simple pycompat.iteritems(x) with x.items() Gregory Szorc <gregory.szorc@gmail.com> parents: 48966 diff changeset	1195 for d, v in self._dirs.items():
39532 93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	1196 sdirs[d] = v.copy()
26402 05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1197 s._files = dict.copy(self._files)
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1198 s._flags = dict.copy(self._flags)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1199
26402 05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1200 if self._loadfunc is _noop:
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1201 _copyfunc(copy)
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1202 else:
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1203 copy._copyfunc = _copyfunc
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1204 else:
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1205 copy._copyfunc = self._copyfunc
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1206 return copy
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1207
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1208 def filesnotin(
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	1209 self, m2: 'treemanifest', match: Optional[matchmod.basematcher] = None
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1210 ) -> Set[bytes]:
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1211 '''Set of files in this manifest that are not in the other'''
39534 8798be5f04fc treemanifest: avoid unnecessary copies/processing when using alwaysmatcher Kyle Lippincott <spectral@google.com> parents: 39533 diff changeset	1212 if match and not match.always():
44386 0bf3b5e80d30 manifest: move matches method to be outside the interface Augie Fackler <augie@google.com> parents: 44332 diff changeset	1213 m1 = self._matches(match)
0bf3b5e80d30 manifest: move matches method to be outside the interface Augie Fackler <augie@google.com> parents: 44332 diff changeset	1214 m2 = m2._matches(match)
31265 959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	1215 return m1.filesnotin(m2)
959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	1216
24405 cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	1217 files = set()
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1218
24405 cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	1219 def _filesnotin(t1, t2):
25220 f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1220 if t1._node == t2._node and not t1._dirty and not t2._dirty:
f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1221 return
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1222 t1._load()
0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1223 t2._load()
40039 906c95073ff7 treemanifests: extract _loaddifflazy from _diff, use in _filesnotin spectral <spectral@google.com> parents: 39988 diff changeset	1224 self._loaddifflazy(t1, t2)
49004 f254fc73d956 global: bulk replace simple pycompat.iteritems(x) with x.items() Gregory Szorc <gregory.szorc@gmail.com> parents: 48966 diff changeset	1225 for d, m1 in t1._dirs.items():
24405 cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	1226 if d in t2._dirs:
cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	1227 m2 = t2._dirs[d]
cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	1228 _filesnotin(m1, m2)
cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	1229 else:
cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	1230 files.update(m1.iterkeys())
cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	1231
36333 413c179cf7d5 manifest: correct the one use of iterkeys() on a dict Augie Fackler <augie@google.com> parents: 36212 diff changeset	1232 for fn in t1._files:
24405 cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	1233 if fn not in t2._files:
cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	1234 files.add(t1._subpath(fn))
cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	1235
cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	1236 _filesnotin(self, m2)
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1237 return files
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1238
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1239 @propertycache
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1240 def _alldirs(self) -> pathutil.dirs:
43571 c21aca51b392 utils: move the `dirs` definition in pathutil (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43554 diff changeset	1241 return pathutil.dirs(self)
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1242
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1243 def dirs(self) -> pathutil.dirs:
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1244 return self._alldirs
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1245
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1246 def hasdir(self, dir: bytes) -> bool:
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1247 self._load()
24406 1297480ed347 treemanifest: make hasdir() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24405 diff changeset	1248 topdir, subdir = _splittopdir(dir)
1297480ed347 treemanifest: make hasdir() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24405 diff changeset	1249 if topdir:
39984 3cacb74c3a22 treemanifests: skip extraneous check for item before calling _loadlazy spectral <spectral@google.com> parents: 39983 diff changeset	1250 self._loadlazy(topdir)
24406 1297480ed347 treemanifest: make hasdir() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24405 diff changeset	1251 if topdir in self._dirs:
1297480ed347 treemanifest: make hasdir() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24405 diff changeset	1252 return self._dirs[topdir].hasdir(subdir)
1297480ed347 treemanifest: make hasdir() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24405 diff changeset	1253 return False
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1254 dirslash = dir + b'/'
39532 93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	1255 return dirslash in self._dirs or dirslash in self._lazydirs
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1256
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1257 def walk(self, match: matchmod.basematcher) -> Iterator[bytes]:
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	1258 """Generates matching file names.
24646 5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	1259
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	1260 It also reports nonexistent files by marking them bad with match.bad().
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	1261 """
24683 4eaea0ed8dc1 manifest.walk: special-case match.always() for speed Martin von Zweigbergk <martinvonz@google.com> parents: 24682 diff changeset	1262 if match.always():
4eaea0ed8dc1 manifest.walk: special-case match.always() for speed Martin von Zweigbergk <martinvonz@google.com> parents: 24682 diff changeset	1263 for f in iter(self):
4eaea0ed8dc1 manifest.walk: special-case match.always() for speed Martin von Zweigbergk <martinvonz@google.com> parents: 24682 diff changeset	1264 yield f
4eaea0ed8dc1 manifest.walk: special-case match.always() for speed Martin von Zweigbergk <martinvonz@google.com> parents: 24682 diff changeset	1265 return
4eaea0ed8dc1 manifest.walk: special-case match.always() for speed Martin von Zweigbergk <martinvonz@google.com> parents: 24682 diff changeset	1266
24646 5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	1267 fset = set(match.files())
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	1268
24647 fb446c57f8f9 treemanifest: refactor treemanifest.walk() Drew Gottlieb <drgott@google.com> parents: 24646 diff changeset	1269 for fn in self._walk(match):
24646 5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	1270 if fn in fset:
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	1271 # specified pattern is the exact name
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	1272 fset.remove(fn)
24647 fb446c57f8f9 treemanifest: refactor treemanifest.walk() Drew Gottlieb <drgott@google.com> parents: 24646 diff changeset	1273 yield fn
24646 5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	1274
42363 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41970 diff changeset	1275 # for dirstate.walk, files=[''] means "walk the whole tree".
24646 5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	1276 # follow that here, too
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1277 fset.discard(b'')
24646 5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	1278
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	1279 for fn in sorted(fset):
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	1280 if not self.hasdir(fn):
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	1281 match.bad(fn, None)
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	1282
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1283 def _walk(self, match: matchmod.basematcher) -> Iterator[bytes]:
25188 2773540c3650 match: remove unnecessary optimization where visitdir() returns 'all' Drew Gottlieb <drgott@google.com> parents: 25185 diff changeset	1284 '''Recursively generates matching file names for walk().'''
42363 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41970 diff changeset	1285 visit = match.visitchildrenset(self._dir[:-1])
39539 3ba9ef0fb693 treemanifest: use visitchildrenset when doing a walk Kyle Lippincott <spectral@google.com> parents: 39538 diff changeset	1286 if not visit:
25188 2773540c3650 match: remove unnecessary optimization where visitdir() returns 'all' Drew Gottlieb <drgott@google.com> parents: 25185 diff changeset	1287 return
24647 fb446c57f8f9 treemanifest: refactor treemanifest.walk() Drew Gottlieb <drgott@google.com> parents: 24646 diff changeset	1288
fb446c57f8f9 treemanifest: refactor treemanifest.walk() Drew Gottlieb <drgott@google.com> parents: 24646 diff changeset	1289 # yield this dir's files and walk its submanifests
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1290 self._load()
39539 3ba9ef0fb693 treemanifest: use visitchildrenset when doing a walk Kyle Lippincott <spectral@google.com> parents: 39538 diff changeset	1291 visit = self._loadchildrensetlazy(visit)
36334 5245bac09e6a manifest: use list(dict) instead of dict.keys() to get a list of keys Augie Fackler <augie@google.com> parents: 36333 diff changeset	1292 for p in sorted(list(self._dirs) + list(self._files)):
24647 fb446c57f8f9 treemanifest: refactor treemanifest.walk() Drew Gottlieb <drgott@google.com> parents: 24646 diff changeset	1293 if p in self._files:
fb446c57f8f9 treemanifest: refactor treemanifest.walk() Drew Gottlieb <drgott@google.com> parents: 24646 diff changeset	1294 fullp = self._subpath(p)
fb446c57f8f9 treemanifest: refactor treemanifest.walk() Drew Gottlieb <drgott@google.com> parents: 24646 diff changeset	1295 if match(fullp):
fb446c57f8f9 treemanifest: refactor treemanifest.walk() Drew Gottlieb <drgott@google.com> parents: 24646 diff changeset	1296 yield fullp
fb446c57f8f9 treemanifest: refactor treemanifest.walk() Drew Gottlieb <drgott@google.com> parents: 24646 diff changeset	1297 else:
39539 3ba9ef0fb693 treemanifest: use visitchildrenset when doing a walk Kyle Lippincott <spectral@google.com> parents: 39538 diff changeset	1298 if not visit or p[:-1] in visit:
3ba9ef0fb693 treemanifest: use visitchildrenset when doing a walk Kyle Lippincott <spectral@google.com> parents: 39538 diff changeset	1299 for f in self._dirs[p]._walk(match):
3ba9ef0fb693 treemanifest: use visitchildrenset when doing a walk Kyle Lippincott <spectral@google.com> parents: 39538 diff changeset	1300 yield f
24647 fb446c57f8f9 treemanifest: refactor treemanifest.walk() Drew Gottlieb <drgott@google.com> parents: 24646 diff changeset	1301
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	1302 def _matches(self, match: matchmod.basematcher) -> 'treemanifest':
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	1303 """recursively generate a new manifest filtered by the match argument."""
44386 0bf3b5e80d30 manifest: move matches method to be outside the interface Augie Fackler <augie@google.com> parents: 44332 diff changeset	1304 if match.always():
0bf3b5e80d30 manifest: move matches method to be outside the interface Augie Fackler <augie@google.com> parents: 44332 diff changeset	1305 return self.copy()
0bf3b5e80d30 manifest: move matches method to be outside the interface Augie Fackler <augie@google.com> parents: 44332 diff changeset	1306 return self._matches_inner(match)
0bf3b5e80d30 manifest: move matches method to be outside the interface Augie Fackler <augie@google.com> parents: 44332 diff changeset	1307
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	1308 def _matches_inner(self, match: matchmod.basematcher) -> 'treemanifest':
44386 0bf3b5e80d30 manifest: move matches method to be outside the interface Augie Fackler <augie@google.com> parents: 44332 diff changeset	1309 if match.always():
0bf3b5e80d30 manifest: move matches method to be outside the interface Augie Fackler <augie@google.com> parents: 44332 diff changeset	1310 return self.copy()
27343 c59647c6694d treemanifest: don't iterate entire matching submanifests on match() Martin von Zweigbergk <martinvonz@google.com> parents: 27271 diff changeset	1311
42363 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41970 diff changeset	1312 visit = match.visitchildrenset(self._dir[:-1])
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1313 if visit == b'all':
27343 c59647c6694d treemanifest: don't iterate entire matching submanifests on match() Martin von Zweigbergk <martinvonz@google.com> parents: 27271 diff changeset	1314 return self.copy()
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	1315 ret = treemanifest(self.nodeconstants, self._dir)
27343 c59647c6694d treemanifest: don't iterate entire matching submanifests on match() Martin von Zweigbergk <martinvonz@google.com> parents: 27271 diff changeset	1316 if not visit:
25188 2773540c3650 match: remove unnecessary optimization where visitdir() returns 'all' Drew Gottlieb <drgott@google.com> parents: 25185 diff changeset	1317 return ret
24552 a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1318
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1319 self._load()
24552 a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1320 for fn in self._files:
39538 154e4f84b51c treemanifest: use visitchildrenset when filtering a manifest to a matcher Kyle Lippincott <spectral@google.com> parents: 39535 diff changeset	1321 # While visitchildrenset usually lists only subdirs, this is
154e4f84b51c treemanifest: use visitchildrenset when filtering a manifest to a matcher Kyle Lippincott <spectral@google.com> parents: 39535 diff changeset	1322 # actually up to the matcher and may have some files in the set().
154e4f84b51c treemanifest: use visitchildrenset when filtering a manifest to a matcher Kyle Lippincott <spectral@google.com> parents: 39535 diff changeset	1323 # If visit == 'this', we should obviously look at the files in this
154e4f84b51c treemanifest: use visitchildrenset when filtering a manifest to a matcher Kyle Lippincott <spectral@google.com> parents: 39535 diff changeset	1324 # directory; if visit is a set, and fn is in it, we should inspect
154e4f84b51c treemanifest: use visitchildrenset when filtering a manifest to a matcher Kyle Lippincott <spectral@google.com> parents: 39535 diff changeset	1325 # fn (but no need to inspect things not in the set).
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1326 if visit != b'this' and fn not in visit:
39538 154e4f84b51c treemanifest: use visitchildrenset when filtering a manifest to a matcher Kyle Lippincott <spectral@google.com> parents: 39535 diff changeset	1327 continue
24552 a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1328 fullp = self._subpath(fn)
39538 154e4f84b51c treemanifest: use visitchildrenset when filtering a manifest to a matcher Kyle Lippincott <spectral@google.com> parents: 39535 diff changeset	1329 # visitchildrenset isn't perfect, we still need to call the regular
154e4f84b51c treemanifest: use visitchildrenset when filtering a manifest to a matcher Kyle Lippincott <spectral@google.com> parents: 39535 diff changeset	1330 # matcher code to further filter results.
24552 a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1331 if not match(fullp):
a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1332 continue
a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1333 ret._files[fn] = self._files[fn]
a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1334 if fn in self._flags:
a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1335 ret._flags[fn] = self._flags[fn]
a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1336
39538 154e4f84b51c treemanifest: use visitchildrenset when filtering a manifest to a matcher Kyle Lippincott <spectral@google.com> parents: 39535 diff changeset	1337 visit = self._loadchildrensetlazy(visit)
49004 f254fc73d956 global: bulk replace simple pycompat.iteritems(x) with x.items() Gregory Szorc <gregory.szorc@gmail.com> parents: 48966 diff changeset	1338 for dir, subm in self._dirs.items():
39538 154e4f84b51c treemanifest: use visitchildrenset when filtering a manifest to a matcher Kyle Lippincott <spectral@google.com> parents: 39535 diff changeset	1339 if visit and dir[:-1] not in visit:
154e4f84b51c treemanifest: use visitchildrenset when filtering a manifest to a matcher Kyle Lippincott <spectral@google.com> parents: 39535 diff changeset	1340 continue
44386 0bf3b5e80d30 manifest: move matches method to be outside the interface Augie Fackler <augie@google.com> parents: 44332 diff changeset	1341 m = subm._matches_inner(match)
24552 a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1342 if not m._isempty():
a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1343 ret._dirs[dir] = m
a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1344
25220 f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1345 if not ret._isempty():
f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1346 ret._dirty = True
24552 a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1347 return ret
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1348
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1349 def fastdelta(
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1350 self, base: ByteString, changes: Iterable[Tuple[bytes, bool]]
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1351 ) -> ByteString:
44665 948fac24bc39 manifest: introduce new exception to signal unavailability of fastdelta() Augie Fackler <augie@google.com> parents: 44386 diff changeset	1352 raise FastdeltaUnavailable()
948fac24bc39 manifest: introduce new exception to signal unavailability of fastdelta() Augie Fackler <augie@google.com> parents: 44386 diff changeset	1353
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1354 def diff(
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1355 self,
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	1356 m2: 'treemanifest',
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1357 match: Optional[matchmod.basematcher] = None,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1358 clean: bool = False,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1359 ) -> Dict[
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1360 bytes,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1361 Optional[
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1362 Tuple[Tuple[Optional[bytes], bytes], Tuple[Optional[bytes], bytes]]
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1363 ],
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1364 ]:
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	1365 """Finds changes between the current manifest and m2.
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1366
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1367 Args:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1368 m2: the manifest to which this manifest should be compared.
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1369 clean: if true, include files unchanged between these manifests
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1370 with a None value in the returned dictionary.
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1371
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1372 The result is returned as a dict with filename as key and
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1373 values of the form ((n1,fl1),(n2,fl2)), where n1/n2 is the
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1374 nodeid in the current/other manifest and fl1/fl2 is the flag
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1375 in the current/other manifest. Where the file does not exist,
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1376 the nodeid will be None and the flags will be the empty
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1377 string.
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	1378 """
39534 8798be5f04fc treemanifest: avoid unnecessary copies/processing when using alwaysmatcher Kyle Lippincott <spectral@google.com> parents: 39533 diff changeset	1379 if match and not match.always():
44386 0bf3b5e80d30 manifest: move matches method to be outside the interface Augie Fackler <augie@google.com> parents: 44332 diff changeset	1380 m1 = self._matches(match)
0bf3b5e80d30 manifest: move matches method to be outside the interface Augie Fackler <augie@google.com> parents: 44332 diff changeset	1381 m2 = m2._matches(match)
31265 959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	1382 return m1.diff(m2, clean=clean)
24404 96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1383 result = {}
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	1384 emptytree = treemanifest(self.nodeconstants)
41153 2c3f69855ce8 manifest: convert a recursive function to iterative one using stacks Pulkit Goyal <pulkit@yandex-team.ru> parents: 41041 diff changeset	1385
2c3f69855ce8 manifest: convert a recursive function to iterative one using stacks Pulkit Goyal <pulkit@yandex-team.ru> parents: 41041 diff changeset	1386 def _iterativediff(t1, t2, stack):
2c3f69855ce8 manifest: convert a recursive function to iterative one using stacks Pulkit Goyal <pulkit@yandex-team.ru> parents: 41041 diff changeset	1387 """compares two tree manifests and append new tree-manifests which
2c3f69855ce8 manifest: convert a recursive function to iterative one using stacks Pulkit Goyal <pulkit@yandex-team.ru> parents: 41041 diff changeset	1388 needs to be compared to stack"""
25220 f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1389 if t1._node == t2._node and not t1._dirty and not t2._dirty:
f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1390 return
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1391 t1._load()
0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1392 t2._load()
40039 906c95073ff7 treemanifests: extract _loaddifflazy from _diff, use in _filesnotin spectral <spectral@google.com> parents: 39988 diff changeset	1393 self._loaddifflazy(t1, t2)
39985 731961d972ba treemanifests: remove _loadalllazy in _diff() spectral <spectral@google.com> parents: 39984 diff changeset	1394
49004 f254fc73d956 global: bulk replace simple pycompat.iteritems(x) with x.items() Gregory Szorc <gregory.szorc@gmail.com> parents: 48966 diff changeset	1395 for d, m1 in t1._dirs.items():
24404 96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1396 m2 = t2._dirs.get(d, emptytree)
41153 2c3f69855ce8 manifest: convert a recursive function to iterative one using stacks Pulkit Goyal <pulkit@yandex-team.ru> parents: 41041 diff changeset	1397 stack.append((m1, m2))
24404 96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1398
49004 f254fc73d956 global: bulk replace simple pycompat.iteritems(x) with x.items() Gregory Szorc <gregory.szorc@gmail.com> parents: 48966 diff changeset	1399 for d, m2 in t2._dirs.items():
24404 96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1400 if d not in t1._dirs:
41153 2c3f69855ce8 manifest: convert a recursive function to iterative one using stacks Pulkit Goyal <pulkit@yandex-team.ru> parents: 41041 diff changeset	1401 stack.append((emptytree, m2))
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1402
49004 f254fc73d956 global: bulk replace simple pycompat.iteritems(x) with x.items() Gregory Szorc <gregory.szorc@gmail.com> parents: 48966 diff changeset	1403 for fn, n1 in t1._files.items():
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1404 fl1 = t1._flags.get(fn, b'')
24404 96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1405 n2 = t2._files.get(fn, None)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1406 fl2 = t2._flags.get(fn, b'')
24404 96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1407 if n1 != n2 or fl1 != fl2:
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1408 result[t1._subpath(fn)] = ((n1, fl1), (n2, fl2))
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1409 elif clean:
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1410 result[t1._subpath(fn)] = None
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1411
49004 f254fc73d956 global: bulk replace simple pycompat.iteritems(x) with x.items() Gregory Szorc <gregory.szorc@gmail.com> parents: 48966 diff changeset	1412 for fn, n2 in t2._files.items():
24404 96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1413 if fn not in t1._files:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1414 fl2 = t2._flags.get(fn, b'')
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1415 result[t2._subpath(fn)] = ((None, b''), (n2, fl2))
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1416
41153 2c3f69855ce8 manifest: convert a recursive function to iterative one using stacks Pulkit Goyal <pulkit@yandex-team.ru> parents: 41041 diff changeset	1417 stackls = []
2c3f69855ce8 manifest: convert a recursive function to iterative one using stacks Pulkit Goyal <pulkit@yandex-team.ru> parents: 41041 diff changeset	1418 _iterativediff(self, m2, stackls)
2c3f69855ce8 manifest: convert a recursive function to iterative one using stacks Pulkit Goyal <pulkit@yandex-team.ru> parents: 41041 diff changeset	1419 while stackls:
2c3f69855ce8 manifest: convert a recursive function to iterative one using stacks Pulkit Goyal <pulkit@yandex-team.ru> parents: 41041 diff changeset	1420 t1, t2 = stackls.pop()
2c3f69855ce8 manifest: convert a recursive function to iterative one using stacks Pulkit Goyal <pulkit@yandex-team.ru> parents: 41041 diff changeset	1421 # stackls is populated in the function call
2c3f69855ce8 manifest: convert a recursive function to iterative one using stacks Pulkit Goyal <pulkit@yandex-team.ru> parents: 41041 diff changeset	1422 _iterativediff(t1, t2, stackls)
24404 96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1423 return result
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1424
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	1425 def unmodifiedsince(self, m2: 'treemanifest') -> bool:
25221 eafa06e9edde treemanifest: speed up commit using dirty flag Martin von Zweigbergk <martinvonz@google.com> parents: 25220 diff changeset	1426 return not self._dirty and not m2._dirty and self._node == m2._node
eafa06e9edde treemanifest: speed up commit using dirty flag Martin von Zweigbergk <martinvonz@google.com> parents: 25220 diff changeset	1427
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1428 def parse(
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1429 self,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1430 text: bytes,
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	1431 readsubtree: Callable[[bytes, bytes], 'treemanifest'],
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1432 ) -> None:
39532 93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	1433 selflazy = self._lazydirs
47083 12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	1434 for f, n, fl in _parse(self._nodelen, text):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1435 if fl == b't':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1436 f = f + b'/'
40040 a0c18b271ea1 treemanifests: store whether a lazydirs entry needs copied after materializing spectral <spectral@google.com> parents: 40039 diff changeset	1437 # False below means "doesn't need to be copied" and can use the
a0c18b271ea1 treemanifests: store whether a lazydirs entry needs copied after materializing spectral <spectral@google.com> parents: 40039 diff changeset	1438 # cached value from readsubtree directly.
46096 93e09d370003 treemanifest: stop storing full path for each item in manifest._lazydirs Kyle Lippincott <spectral@google.com> parents: 45957 diff changeset	1439 selflazy[f] = (n, readsubtree, False)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1440 elif b'/' in f:
25220 f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1441 # This is a flat manifest, so use __setitem__ and setflag rather
f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1442 # than assigning directly to _files and _flags, so we can
f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1443 # assign a path in a subdirectory, and to mark dirty (compared
f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1444 # to nullid).
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1445 self[f] = n
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1446 if fl:
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1447 self.setflag(f, fl)
25220 f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1448 else:
f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1449 # Assigning to _files and _flags avoids marking as dirty,
f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1450 # and should be a little faster.
f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1451 self._files[f] = n
f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1452 if fl:
f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1453 self._flags[f] = fl
24781 055b3cbe6c57 treemanifest: extract parse method from constructor Martin von Zweigbergk <martinvonz@google.com> parents: 24780 diff changeset	1454
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1455 def text(self) -> ByteString:
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1456 """Get the full data of this manifest as a bytestring."""
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1457 self._load()
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	1458 return _text(self.iterentries())
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1459
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1460 def dirtext(self) -> ByteString:
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1461 """Get the full data of this directory as a bytestring. Make sure that
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1462 any submanifests have been written first, so their nodeids are correct.
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1463 """
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1464 self._load()
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1465 flags = self.flags
49004 f254fc73d956 global: bulk replace simple pycompat.iteritems(x) with x.items() Gregory Szorc <gregory.szorc@gmail.com> parents: 48966 diff changeset	1466 lazydirs = [(d[:-1], v[0], b't') for d, v in self._lazydirs.items()]
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1467 dirs = [(d[:-1], self._dirs[d]._node, b't') for d in self._dirs]
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1468 files = [(f, self._files[f], flags(f)) for f in self._files]
39532 93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	1469 return _text(sorted(dirs + files + lazydirs))
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1470
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1471 def read(
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1472 self,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1473 gettext: Callable[[], ByteString],
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	1474 readsubtree: Callable[[bytes, bytes], 'treemanifest'],
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1475 ) -> None:
26402 05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1476 def _load_for_read(s):
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1477 s.parse(gettext(), readsubtree)
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1478 s._dirty = False
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1479
26402 05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1480 self._loadfunc = _load_for_read
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1481
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1482 def writesubtrees(
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1483 self,
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	1484 m1: 'treemanifest',
c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	1485 m2: 'treemanifest',
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1486 writesubtree: Callable[
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1487 [
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	1488 Callable[['treemanifest'], None],
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1489 bytes,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1490 bytes,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1491 matchmod.basematcher,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1492 ],
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1493 None,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1494 ],
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1495 match: matchmod.basematcher,
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1496 ) -> None:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1497 self._load() # for consistency; should never have any effect here
29892 8a84347b9907 manifest: call m1.load and m2.load before writing a subtree Durham Goode <durham@fb.com> parents: 29837 diff changeset	1498 m1._load()
8a84347b9907 manifest: call m1.load and m2.load before writing a subtree Durham Goode <durham@fb.com> parents: 29837 diff changeset	1499 m2._load()
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	1500 emptytree = treemanifest(self.nodeconstants)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1501
39535 c29548ba4a75 treemanifest: avoid loading everything just to get their nodeid Kyle Lippincott <spectral@google.com> parents: 39534 diff changeset	1502 def getnode(m, d):
c29548ba4a75 treemanifest: avoid loading everything just to get their nodeid Kyle Lippincott <spectral@google.com> parents: 39534 diff changeset	1503 ld = m._lazydirs.get(d)
c29548ba4a75 treemanifest: avoid loading everything just to get their nodeid Kyle Lippincott <spectral@google.com> parents: 39534 diff changeset	1504 if ld:
46096 93e09d370003 treemanifest: stop storing full path for each item in manifest._lazydirs Kyle Lippincott <spectral@google.com> parents: 45957 diff changeset	1505 return ld[0]
51825 e2f1efa2bd86 manifest: help pytype to understant `writesubtrees`'s `getnode` type Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51824 diff changeset	1506 tree = m._dirs.get(d, emptytree)
e2f1efa2bd86 manifest: help pytype to understant `writesubtrees`'s `getnode` type Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51824 diff changeset	1507 assert tree is not None # helps pytype
e2f1efa2bd86 manifest: help pytype to understant `writesubtrees`'s `getnode` type Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51824 diff changeset	1508 return tree._node
39535 c29548ba4a75 treemanifest: avoid loading everything just to get their nodeid Kyle Lippincott <spectral@google.com> parents: 39534 diff changeset	1509
39684 24870f1be088 narrow: when writing treemanifests, skip inspecting directories outside narrow spectral <spectral@google.com> parents: 39539 diff changeset	1510 # let's skip investigating things that `match` says we do not need.
42363 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41970 diff changeset	1511 visit = match.visitchildrenset(self._dir[:-1])
40041 67b93cd847fb treemanifests: remove _loadalllazy when doing copies spectral <spectral@google.com> parents: 40040 diff changeset	1512 visit = self._loadchildrensetlazy(visit)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1513 if visit == b'this' or visit == b'all':
39684 24870f1be088 narrow: when writing treemanifests, skip inspecting directories outside narrow spectral <spectral@google.com> parents: 39539 diff changeset	1514 visit = None
49004 f254fc73d956 global: bulk replace simple pycompat.iteritems(x) with x.items() Gregory Szorc <gregory.szorc@gmail.com> parents: 48966 diff changeset	1515 for d, subm in self._dirs.items():
39684 24870f1be088 narrow: when writing treemanifests, skip inspecting directories outside narrow spectral <spectral@google.com> parents: 39539 diff changeset	1516 if visit and d[:-1] not in visit:
24870f1be088 narrow: when writing treemanifests, skip inspecting directories outside narrow spectral <spectral@google.com> parents: 39539 diff changeset	1517 continue
39535 c29548ba4a75 treemanifest: avoid loading everything just to get their nodeid Kyle Lippincott <spectral@google.com> parents: 39534 diff changeset	1518 subp1 = getnode(m1, d)
c29548ba4a75 treemanifest: avoid loading everything just to get their nodeid Kyle Lippincott <spectral@google.com> parents: 39534 diff changeset	1519 subp2 = getnode(m2, d)
47055 d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	1520 if subp1 == self.nodeconstants.nullid:
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1521 subp1, subp2 = subp2, subp1
39684 24870f1be088 narrow: when writing treemanifests, skip inspecting directories outside narrow spectral <spectral@google.com> parents: 39539 diff changeset	1522 writesubtree(subm, subp1, subp2, match)
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1523
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1524 def walksubtrees(
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1525 self, matcher: Optional[matchmod.basematcher] = None
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	1526 ) -> Iterator['treemanifest']:
31876 94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1527 """Returns an iterator of the subtrees of this manifest, including this
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1528 manifest itself.
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1529
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1530 If `matcher` is provided, it only returns subtrees that match.
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1531 """
42363 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41970 diff changeset	1532 if matcher and not matcher.visitdir(self._dir[:-1]):
31876 94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1533 return
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1534 if not matcher or matcher(self._dir[:-1]):
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1535 yield self
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1536
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1537 self._load()
39532 93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	1538 # OPT: use visitchildrenset to avoid loading everything.
93486cc46125 treemanifest: introduce lazy loading of subdirs spectral <spectral@google.com> parents: 39349 diff changeset	1539 self._loadalllazy()
49004 f254fc73d956 global: bulk replace simple pycompat.iteritems(x) with x.items() Gregory Szorc <gregory.szorc@gmail.com> parents: 48966 diff changeset	1540 for d, subm in self._dirs.items():
31876 94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1541 for subtree in subm.walksubtrees(matcher=matcher):
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1542 yield subtree
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1543
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1544
38821 0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1545 class manifestfulltextcache(util.lrucachedict):
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1546 """File-backed LRU cache for the manifest cache
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1547
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1548 File consists of entries, up to EOF:
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1549
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1550 - 20 bytes node, 4 bytes length, <length> manifest data
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1551
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1552 These are written in reverse cache order (oldest to newest).
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1553
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1554 """
41967 07c80298b5a1 manifestcache: abstract the filename in a class attribute Pierre-Yves David <pierre-yves.david@octobus.net> parents: 41966 diff changeset	1555
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1556 _file = b'manifestfulltextcache'
41967 07c80298b5a1 manifestcache: abstract the filename in a class attribute Pierre-Yves David <pierre-yves.david@octobus.net> parents: 41966 diff changeset	1557
38821 0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1558 def __init__(self, max):
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1559 super(manifestfulltextcache, self).__init__(max)
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1560 self._dirty = False
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1561 self._read = False
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1562 self._opener = None
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1563
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1564 def read(self):
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1565 if self._read or self._opener is None:
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1566 return
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1567
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1568 try:
41967 07c80298b5a1 manifestcache: abstract the filename in a class attribute Pierre-Yves David <pierre-yves.david@octobus.net> parents: 41966 diff changeset	1569 with self._opener(self._file) as fp:
38821 0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1570 set = super(manifestfulltextcache, self).__setitem__
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1571 # ignore trailing data, this is a cache, corruption is skipped
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1572 while True:
44708 61134a232d00 manifest: leave a TODO where we may have more work for sha1 portability Augie Fackler <augie@google.com> parents: 44706 diff changeset	1573 # TODO do we need to do work here for sha1 portability?
38821 0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1574 node = fp.read(20)
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1575 if len(node) < 20:
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1576 break
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1577 try:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1578 size = struct.unpack(b'>L', fp.read(4))[0]
38821 0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1579 except struct.error:
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1580 break
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1581 value = bytearray(fp.read(size))
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1582 if len(value) != size:
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1583 break
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1584 set(node, value)
52665 24ee91ba9aa8 pyupgrade: drop usage of py3 aliases for `OSError` Matt Harbison <matt_harbison@yahoo.com> parents: 52524 diff changeset	1585 except OSError:
38821 0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1586 # the file is allowed to be missing
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1587 pass
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1588
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1589 self._read = True
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1590 self._dirty = False
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1591
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1592 def write(self):
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1593 if not self._dirty or self._opener is None:
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1594 return
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1595 # rotate backwards to the first used node
44773 35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1596 try:
35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1597 with self._opener(
35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1598 self._file, b'w', atomictemp=True, checkambig=True
35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1599 ) as fp:
35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1600 node = self._head.prev
35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1601 while True:
35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1602 if node.key in self._cache:
35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1603 fp.write(node.key)
35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1604 fp.write(struct.pack(b'>L', len(node.value)))
35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1605 fp.write(node.value)
35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1606 if node is self._head:
35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1607 break
35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1608 node = node.prev
52665 24ee91ba9aa8 pyupgrade: drop usage of py3 aliases for `OSError` Matt Harbison <matt_harbison@yahoo.com> parents: 52524 diff changeset	1609 except OSError:
44773 35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1610 # We could not write the cache (eg: permission error)
35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1611 # the content can be missing.
35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1612 #
35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1613 # We could try harder and see if we could recreate a wcache
35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1614 # directory were we coudl write too.
35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1615 #
35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1616 # XXX the error pass silently, having some way to issue an error
35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1617 # log `ui.log` would be nice.
35bb67427f63 manifest-cache: ignore IOError while writing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44708 diff changeset	1618 pass
38821 0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1619
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1620 def __len__(self):
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1621 if not self._read:
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1622 self.read()
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1623 return super(manifestfulltextcache, self).__len__()
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1624
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1625 def __contains__(self, k):
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1626 if not self._read:
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1627 self.read()
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1628 return super(manifestfulltextcache, self).__contains__(k)
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1629
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1630 def __iter__(self):
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1631 if not self._read:
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1632 self.read()
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1633 return super(manifestfulltextcache, self).__iter__()
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1634
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1635 def __getitem__(self, k):
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1636 if not self._read:
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1637 self.read()
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1638 # the cache lru order can change on read
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1639 setdirty = self._cache.get(k) is not self._head
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1640 value = super(manifestfulltextcache, self).__getitem__(k)
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1641 if setdirty:
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1642 self._dirty = True
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1643 return value
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1644
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1645 def __setitem__(self, k, v):
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1646 if not self._read:
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1647 self.read()
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1648 super(manifestfulltextcache, self).__setitem__(k, v)
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1649 self._dirty = True
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1650
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1651 def __delitem__(self, k):
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1652 if not self._read:
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1653 self.read()
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1654 super(manifestfulltextcache, self).__delitem__(k)
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1655 self._dirty = True
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1656
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1657 def get(self, k, default=None):
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1658 if not self._read:
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1659 self.read()
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1660 return super(manifestfulltextcache, self).get(k, default=default)
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1661
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1662 def clear(self, clear_persisted_data=False):
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1663 super(manifestfulltextcache, self).clear()
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1664 if clear_persisted_data:
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1665 self._dirty = True
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1666 self.write()
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1667 self._read = False
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1668
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1669
42478 bc4373babd04 revlog: add the option to track the expected compression upper bound Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42399 diff changeset	1670 # and upper bound of what we expect from compression
bc4373babd04 revlog: add the option to track the expected compression upper bound Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42399 diff changeset	1671 # (real live value seems to be "3")
42485 4a3abb33380a deltas: set estimated compression upper bound to "3x" instead of "10x" Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42478 diff changeset	1672 MAXCOMPRESSION = 3
42478 bc4373babd04 revlog: add the option to track the expected compression upper bound Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42399 diff changeset	1673
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1674
44665 948fac24bc39 manifest: introduce new exception to signal unavailability of fastdelta() Augie Fackler <augie@google.com> parents: 44386 diff changeset	1675 class FastdeltaUnavailable(Exception):
948fac24bc39 manifest: introduce new exception to signal unavailability of fastdelta() Augie Fackler <augie@google.com> parents: 44386 diff changeset	1676 """Exception raised when fastdelta isn't usable on a manifest."""
948fac24bc39 manifest: introduce new exception to signal unavailability of fastdelta() Augie Fackler <augie@google.com> parents: 44386 diff changeset	1677
948fac24bc39 manifest: introduce new exception to signal unavailability of fastdelta() Augie Fackler <augie@google.com> parents: 44386 diff changeset	1678
52093 4675ab746a02 manifest: drop the CamelCase name for `manifest.manifestrevlog` Matt Harbison <matt_harbison@yahoo.com> parents: 52092 diff changeset	1679 class manifestrevlog: # (repository.imanifeststorage)
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	1680 """A revlog that stores manifest texts. This is responsible for caching the
29835 58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1681 full-text manifest contents.
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	1682 """
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1683
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1684 def __init__(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1685 self,
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	1686 nodeconstants,
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1687 opener,
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1688 tree=b'',
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1689 dirlogcache=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1690 treemanifest=False,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1691 ):
31161 6d9f8bc2b5ea manifest: allow specifying the revlog filename Durham Goode <durham@fb.com> parents: 31114 diff changeset	1692 """Constructs a new manifest revlog
6d9f8bc2b5ea manifest: allow specifying the revlog filename Durham Goode <durham@fb.com> parents: 31114 diff changeset	1693
6d9f8bc2b5ea manifest: allow specifying the revlog filename Durham Goode <durham@fb.com> parents: 31114 diff changeset	1694 `indexfile` - used by extensions to have two manifests at once, like
6d9f8bc2b5ea manifest: allow specifying the revlog filename Durham Goode <durham@fb.com> parents: 31114 diff changeset	1695 when transitioning between flatmanifeset and treemanifests.
32292 d67991c4fefe treemanifest: allow manifestrevlog to take an explicit treemanifest arg Durham Goode <durham@fb.com> parents: 32240 diff changeset	1696
d67991c4fefe treemanifest: allow manifestrevlog to take an explicit treemanifest arg Durham Goode <durham@fb.com> parents: 32240 diff changeset	1697 `treemanifest` - used to indicate this is a tree manifest revlog. Opener
d67991c4fefe treemanifest: allow manifestrevlog to take an explicit treemanifest arg Durham Goode <durham@fb.com> parents: 32240 diff changeset	1698 options can also be used to make this a tree manifest revlog. The opener
d67991c4fefe treemanifest: allow manifestrevlog to take an explicit treemanifest arg Durham Goode <durham@fb.com> parents: 32240 diff changeset	1699 option takes precedence, so if it is set to True, we ignore whatever
d67991c4fefe treemanifest: allow manifestrevlog to take an explicit treemanifest arg Durham Goode <durham@fb.com> parents: 32240 diff changeset	1700 value is passed in to the constructor.
31161 6d9f8bc2b5ea manifest: allow specifying the revlog filename Durham Goode <durham@fb.com> parents: 31114 diff changeset	1701 """
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	1702 self.nodeconstants = nodeconstants
29835 58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1703 # During normal operations, we expect to deal with not more than four
58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1704 # revs at a time (such as during commit --amend). When rebasing large
58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1705 # stacks of commits, the number can go up, hence the config knob below.
58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1706 cachesize = 4
32292 d67991c4fefe treemanifest: allow manifestrevlog to take an explicit treemanifest arg Durham Goode <durham@fb.com> parents: 32240 diff changeset	1707 optiontreemanifest = False
51818 f0be60ed6242 manifest: align some vfs option access on the fact we might not have options Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51817 diff changeset	1708 persistentnodemap = False
29835 58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1709 opts = getattr(opener, 'options', None)
58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1710 if opts is not None:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1711 cachesize = opts.get(b'manifestcachesize', cachesize)
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1712 optiontreemanifest = opts.get(b'treemanifest', False)
51818 f0be60ed6242 manifest: align some vfs option access on the fact we might not have options Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51817 diff changeset	1713 persistentnodemap = opts.get(b'persistent-nodemap', False)
29944 fa145a205a7f manifest: move revlog specific options from manifest to manifestrevlog Durham Goode <durham@fb.com> parents: 29943 diff changeset	1714
32292 d67991c4fefe treemanifest: allow manifestrevlog to take an explicit treemanifest arg Durham Goode <durham@fb.com> parents: 32240 diff changeset	1715 self._treeondisk = optiontreemanifest or treemanifest
29944 fa145a205a7f manifest: move revlog specific options from manifest to manifestrevlog Durham Goode <durham@fb.com> parents: 29943 diff changeset	1716
38821 0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1717 self._fulltextcache = manifestfulltextcache(cachesize)
29835 58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1718
39271 0d97530eb535 manifest: rename dir argument and attribute to tree Gregory Szorc <gregory.szorc@gmail.com> parents: 39270 diff changeset	1719 if tree:
49234 b5858e02e3ba manifest: improve error message in case for tree manifest Pierre-Yves David <pierre-yves.david@octobus.net> parents: 49037 diff changeset	1720 assert self._treeondisk, (tree, b'opts is %r' % opts)
31161 6d9f8bc2b5ea manifest: allow specifying the revlog filename Durham Goode <durham@fb.com> parents: 31114 diff changeset	1721
47164 8d3c2f9d4af7 revlog: use a "radix" to address revlog Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47160 diff changeset	1722 radix = b'00manifest'
8d3c2f9d4af7 revlog: use a "radix" to address revlog Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47160 diff changeset	1723 if tree:
8d3c2f9d4af7 revlog: use a "radix" to address revlog Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47160 diff changeset	1724 radix = b"meta/" + tree + radix
31161 6d9f8bc2b5ea manifest: allow specifying the revlog filename Durham Goode <durham@fb.com> parents: 31114 diff changeset	1725
39342 57c3864f3aad manifest: make tree a public attribute Gregory Szorc <gregory.szorc@gmail.com> parents: 39341 diff changeset	1726 self.tree = tree
57c3864f3aad manifest: make tree a public attribute Gregory Szorc <gregory.szorc@gmail.com> parents: 39341 diff changeset	1727
29945 1cc93a154723 manifest: move dirlog up to manifestrevlog Durham Goode <durham@fb.com> parents: 29944 diff changeset	1728 # The dirlogcache is kept on the root manifest log
39271 0d97530eb535 manifest: rename dir argument and attribute to tree Gregory Szorc <gregory.szorc@gmail.com> parents: 39270 diff changeset	1729 if tree:
29945 1cc93a154723 manifest: move dirlog up to manifestrevlog Durham Goode <durham@fb.com> parents: 29944 diff changeset	1730 self._dirlogcache = dirlogcache
1cc93a154723 manifest: move dirlog up to manifestrevlog Durham Goode <durham@fb.com> parents: 29944 diff changeset	1731 else:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1732 self._dirlogcache = {b'': self}
29944 fa145a205a7f manifest: move revlog specific options from manifest to manifestrevlog Durham Goode <durham@fb.com> parents: 29943 diff changeset	1733
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1734 self._revlog = revlog.revlog(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1735 opener,
47089 4c041c71ec01 revlog: introduce an explicit tracking of what the revlog is about Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47083 diff changeset	1736 target=(revlog_constants.KIND_MANIFESTLOG, self.tree),
47164 8d3c2f9d4af7 revlog: use a "radix" to address revlog Pierre-Yves David <pierre-yves.david@octobus.net> parents: 47160 diff changeset	1737 radix=radix,
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1738 # only root indexfile is cached
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1739 checkambig=not bool(tree),
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1740 mmaplargeindex=True,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1741 upperboundcomp=MAXCOMPRESSION,
51818 f0be60ed6242 manifest: align some vfs option access on the fact we might not have options Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51817 diff changeset	1742 persistentnodemap=persistentnodemap,
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1743 )
39341 7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1744
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1745 self.index = self._revlog.index
29944 fa145a205a7f manifest: move revlog specific options from manifest to manifestrevlog Durham Goode <durham@fb.com> parents: 29943 diff changeset	1746
50667 32837c7e2e4b revlog: add a `get_revlog` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 50619 diff changeset	1747 def get_revlog(self):
32837c7e2e4b revlog: add a `get_revlog` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 50619 diff changeset	1748 """return an actual revlog instance if any
32837c7e2e4b revlog: add a `get_revlog` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 50619 diff changeset	1749
32837c7e2e4b revlog: add a `get_revlog` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 50619 diff changeset	1750 This exist because a lot of code leverage the fact the underlying
32837c7e2e4b revlog: add a `get_revlog` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 50619 diff changeset	1751 storage is a revlog for optimization, so giving simple way to access
32837c7e2e4b revlog: add a `get_revlog` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 50619 diff changeset	1752 the revlog instance helps such code.
32837c7e2e4b revlog: add a `get_revlog` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 50619 diff changeset	1753 """
32837c7e2e4b revlog: add a `get_revlog` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 50619 diff changeset	1754 return self._revlog
32837c7e2e4b revlog: add a `get_revlog` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 50619 diff changeset	1755
38821 0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1756 def _setupmanifestcachehooks(self, repo):
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1757 """Persist the manifestfulltextcache on lock release"""
50951 d718eddf01d9 safehasattr: drop usage in favor of hasattr Pierre-Yves David <pierre-yves.david@octobus.net> parents: 50667 diff changeset	1758 if not hasattr(repo, '_wlockref'):
38821 0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1759 return
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1760
41970 e4ac7e63c213 manifestcache: use `wcache` directory for manifest cache Pierre-Yves David <pierre-yves.david@octobus.net> parents: 41969 diff changeset	1761 self._fulltextcache._opener = repo.wcachevfs
41969 d121823072b8 manifestcache: protect write with `wlock` instead of `lock` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 41967 diff changeset	1762 if repo._currentlock(repo._wlockref) is None:
41966 c3522b015f81 manifestcache: skip setup earlier if we don't have the lock Pierre-Yves David <pierre-yves.david@octobus.net> parents: 41387 diff changeset	1763 return
c3522b015f81 manifestcache: skip setup earlier if we don't have the lock Pierre-Yves David <pierre-yves.david@octobus.net> parents: 41387 diff changeset	1764
38821 0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1765 reporef = weakref.ref(repo)
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1766 manifestrevlogref = weakref.ref(self)
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1767
43798 888bd39ed555 lock: pass "success" boolean to _afterlock callbacks Kyle Lippincott <spectral@google.com> parents: 43571 diff changeset	1768 def persistmanifestcache(success):
888bd39ed555 lock: pass "success" boolean to _afterlock callbacks Kyle Lippincott <spectral@google.com> parents: 43571 diff changeset	1769 # Repo is in an unknown state, do not persist.
888bd39ed555 lock: pass "success" boolean to _afterlock callbacks Kyle Lippincott <spectral@google.com> parents: 43571 diff changeset	1770 if not success:
888bd39ed555 lock: pass "success" boolean to _afterlock callbacks Kyle Lippincott <spectral@google.com> parents: 43571 diff changeset	1771 return
888bd39ed555 lock: pass "success" boolean to _afterlock callbacks Kyle Lippincott <spectral@google.com> parents: 43571 diff changeset	1772
38821 0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1773 repo = reporef()
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1774 self = manifestrevlogref()
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1775 if repo is None or self is None:
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1776 return
39347 57301ba47e66 manifest: use public API for obtaining storage object Gregory Szorc <gregory.szorc@gmail.com> parents: 39344 diff changeset	1777 if repo.manifestlog.getstorage(b'') is not self:
38821 0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1778 # there's a different manifest in play now, abort
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1779 return
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1780 self._fulltextcache.write()
0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1781
41966 c3522b015f81 manifestcache: skip setup earlier if we don't have the lock Pierre-Yves David <pierre-yves.david@octobus.net> parents: 41387 diff changeset	1782 repo._afterlock(persistmanifestcache)
38821 0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1783
29835 58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1784 @property
58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1785 def fulltextcache(self):
58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1786 return self._fulltextcache
58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1787
51909 5e79783d4bc7 revlog: make `clearcaches()` signature consistent with ManifestRevlog Matt Harbison <matt_harbison@yahoo.com> parents: 51901 diff changeset	1788 def clearcaches(self, clear_persisted_data: bool = False) -> None:
39341 7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1789 self._revlog.clearcaches()
38821 0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	1790 self._fulltextcache.clear(clear_persisted_data=clear_persisted_data)
39342 57c3864f3aad manifest: make tree a public attribute Gregory Szorc <gregory.szorc@gmail.com> parents: 39341 diff changeset	1791 self._dirlogcache = {self.tree: self}
29945 1cc93a154723 manifest: move dirlog up to manifestrevlog Durham Goode <durham@fb.com> parents: 29944 diff changeset	1792
36133 59adb3051718 manifest: clean up dirlog() to take a d parameter to avoid shadowing dir() Augie Fackler <augie@google.com> parents: 35586 diff changeset	1793 def dirlog(self, d):
59adb3051718 manifest: clean up dirlog() to take a d parameter to avoid shadowing dir() Augie Fackler <augie@google.com> parents: 35586 diff changeset	1794 if d:
29945 1cc93a154723 manifest: move dirlog up to manifestrevlog Durham Goode <durham@fb.com> parents: 29944 diff changeset	1795 assert self._treeondisk
36133 59adb3051718 manifest: clean up dirlog() to take a d parameter to avoid shadowing dir() Augie Fackler <augie@google.com> parents: 35586 diff changeset	1796 if d not in self._dirlogcache:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1797 mfrevlog = manifestrevlog(
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	1798 self.nodeconstants,
6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	1799 self.opener,
6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	1800 d,
6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	1801 self._dirlogcache,
6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	1802 treemanifest=self._treeondisk,
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1803 )
36133 59adb3051718 manifest: clean up dirlog() to take a d parameter to avoid shadowing dir() Augie Fackler <augie@google.com> parents: 35586 diff changeset	1804 self._dirlogcache[d] = mfrevlog
59adb3051718 manifest: clean up dirlog() to take a d parameter to avoid shadowing dir() Augie Fackler <augie@google.com> parents: 35586 diff changeset	1805 return self._dirlogcache[d]
29835 58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1806
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1807 def add(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1808 self,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1809 m,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1810 transaction,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1811 link,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1812 p1,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1813 p2,
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1814 added: Iterable[bytes],
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	1815 removed: Iterable[bytes],
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1816 readtree=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1817 match=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1818 ):
45067 5a80915e99ce commitctx: document the manifest writing function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44911 diff changeset	1819 """add some manifest entry in to the manifest log
5a80915e99ce commitctx: document the manifest writing function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44911 diff changeset	1820
5a80915e99ce commitctx: document the manifest writing function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44911 diff changeset	1821 input:
5a80915e99ce commitctx: document the manifest writing function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44911 diff changeset	1822
5a80915e99ce commitctx: document the manifest writing function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44911 diff changeset	1823 m: the manifest dict we want to store
5a80915e99ce commitctx: document the manifest writing function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44911 diff changeset	1824 transaction: the open transaction
5a80915e99ce commitctx: document the manifest writing function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44911 diff changeset	1825 p1: manifest-node of p1
5a80915e99ce commitctx: document the manifest writing function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44911 diff changeset	1826 p2: manifest-node of p2
5a80915e99ce commitctx: document the manifest writing function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44911 diff changeset	1827 added: file added/changed compared to parent
5a80915e99ce commitctx: document the manifest writing function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44911 diff changeset	1828 removed: file removed compared to parent
5a80915e99ce commitctx: document the manifest writing function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44911 diff changeset	1829
5a80915e99ce commitctx: document the manifest writing function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44911 diff changeset	1830 tree manifest input:
5a80915e99ce commitctx: document the manifest writing function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44911 diff changeset	1831
5a80915e99ce commitctx: document the manifest writing function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44911 diff changeset	1832 readtree: a function to read a subtree
5a80915e99ce commitctx: document the manifest writing function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44911 diff changeset	1833 match: a filematcher for the subpart of the tree manifest
5a80915e99ce commitctx: document the manifest writing function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44911 diff changeset	1834 """
44665 948fac24bc39 manifest: introduce new exception to signal unavailability of fastdelta() Augie Fackler <augie@google.com> parents: 44386 diff changeset	1835 try:
948fac24bc39 manifest: introduce new exception to signal unavailability of fastdelta() Augie Fackler <augie@google.com> parents: 44386 diff changeset	1836 if p1 not in self.fulltextcache:
948fac24bc39 manifest: introduce new exception to signal unavailability of fastdelta() Augie Fackler <augie@google.com> parents: 44386 diff changeset	1837 raise FastdeltaUnavailable()
29965 774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1838 # If our first parent is in the manifest cache, we can
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1839 # compute a delta here using properties we know about the
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1840 # manifest up-front, which may save time later for the
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1841 # revlog layer.
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1842
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1843 _checkforbidden(added)
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1844 # combine the changed lists into one sorted iterator
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1845 work = heapq.merge(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1846 [(x, False) for x in sorted(added)],
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1847 [(x, True) for x in sorted(removed)],
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1848 )
29965 774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1849
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1850 arraytext, deltatext = m.fastdelta(self.fulltextcache[p1], work)
39341 7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1851 cachedelta = self._revlog.rev(p1), deltatext
29965 774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1852 text = util.buffer(arraytext)
46560 f7b61ad3c64a revlog: change addrevision to return the new revision, not node Joerg Sonnenberger <joerg@bec.de> parents: 46445 diff changeset	1853 rev = self._revlog.addrevision(
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1854 text, transaction, link, p1, p2, cachedelta
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1855 )
46560 f7b61ad3c64a revlog: change addrevision to return the new revision, not node Joerg Sonnenberger <joerg@bec.de> parents: 46445 diff changeset	1856 n = self._revlog.node(rev)
44665 948fac24bc39 manifest: introduce new exception to signal unavailability of fastdelta() Augie Fackler <augie@google.com> parents: 44386 diff changeset	1857 except FastdeltaUnavailable:
948fac24bc39 manifest: introduce new exception to signal unavailability of fastdelta() Augie Fackler <augie@google.com> parents: 44386 diff changeset	1858 # The first parent manifest isn't already loaded or the
948fac24bc39 manifest: introduce new exception to signal unavailability of fastdelta() Augie Fackler <augie@google.com> parents: 44386 diff changeset	1859 # manifest implementation doesn't support fastdelta, so
948fac24bc39 manifest: introduce new exception to signal unavailability of fastdelta() Augie Fackler <augie@google.com> parents: 44386 diff changeset	1860 # we'll just encode a fulltext of the manifest and pass
948fac24bc39 manifest: introduce new exception to signal unavailability of fastdelta() Augie Fackler <augie@google.com> parents: 44386 diff changeset	1861 # that through to the revlog layer, and let it handle the
948fac24bc39 manifest: introduce new exception to signal unavailability of fastdelta() Augie Fackler <augie@google.com> parents: 44386 diff changeset	1862 # delta process.
29965 774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1863 if self._treeondisk:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1864 assert readtree, b"readtree must be set for treemanifest writes"
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1865 assert match, b"match must be specified for treemanifest writes"
39342 57c3864f3aad manifest: make tree a public attribute Gregory Szorc <gregory.szorc@gmail.com> parents: 39341 diff changeset	1866 m1 = readtree(self.tree, p1)
57c3864f3aad manifest: make tree a public attribute Gregory Szorc <gregory.szorc@gmail.com> parents: 39341 diff changeset	1867 m2 = readtree(self.tree, p2)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1868 n = self._addtree(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1869 m, transaction, link, m1, m2, readtree, match=match
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1870 )
29965 774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1871 arraytext = None
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1872 else:
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	1873 text = m.text()
46560 f7b61ad3c64a revlog: change addrevision to return the new revision, not node Joerg Sonnenberger <joerg@bec.de> parents: 46445 diff changeset	1874 rev = self._revlog.addrevision(text, transaction, link, p1, p2)
f7b61ad3c64a revlog: change addrevision to return the new revision, not node Joerg Sonnenberger <joerg@bec.de> parents: 46445 diff changeset	1875 n = self._revlog.node(rev)
31355 2a18e9e6ca43 py3: use bytearray() instead of array('c', ...) constructions Augie Fackler <augie@google.com> parents: 31303 diff changeset	1876 arraytext = bytearray(text)
29965 774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1877
30209 9d06b65c5df2 manifest: don't store None in fulltextcache Martin von Zweigbergk <martinvonz@google.com> parents: 30207 diff changeset	1878 if arraytext is not None:
9d06b65c5df2 manifest: don't store None in fulltextcache Martin von Zweigbergk <martinvonz@google.com> parents: 30207 diff changeset	1879 self.fulltextcache[n] = arraytext
29965 774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1880
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1881 return n
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1882
39684 24870f1be088 narrow: when writing treemanifests, skip inspecting directories outside narrow spectral <spectral@google.com> parents: 39539 diff changeset	1883 def _addtree(self, m, transaction, link, m1, m2, readtree, match):
29965 774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1884 # If the manifest is unchanged compared to one parent,
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1885 # don't write a new revision
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1886 if self.tree != b'' and (
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1887 m.unmodifiedsince(m1) or m.unmodifiedsince(m2)
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1888 ):
29965 774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1889 return m.node()
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1890
39684 24870f1be088 narrow: when writing treemanifests, skip inspecting directories outside narrow spectral <spectral@google.com> parents: 39539 diff changeset	1891 def writesubtree(subm, subp1, subp2, match):
29965 774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1892 sublog = self.dirlog(subm.dir())
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1893 sublog.add(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1894 subm,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1895 transaction,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1896 link,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1897 subp1,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1898 subp2,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1899 None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1900 None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1901 readtree=readtree,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1902 match=match,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1903 )
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1904
39684 24870f1be088 narrow: when writing treemanifests, skip inspecting directories outside narrow spectral <spectral@google.com> parents: 39539 diff changeset	1905 m.writesubtrees(m1, m2, writesubtree, match)
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	1906 text = m.dirtext()
31303 c134a33b1d73 treemanifest: make node reuse match flat manifest behavior Durham Goode <durham@fb.com> parents: 31265 diff changeset	1907 n = None
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1908 if self.tree != b'':
31303 c134a33b1d73 treemanifest: make node reuse match flat manifest behavior Durham Goode <durham@fb.com> parents: 31265 diff changeset	1909 # Double-check whether contents are unchanged to one parent
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	1910 if text == m1.dirtext():
31303 c134a33b1d73 treemanifest: make node reuse match flat manifest behavior Durham Goode <durham@fb.com> parents: 31265 diff changeset	1911 n = m1.node()
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	1912 elif text == m2.dirtext():
31303 c134a33b1d73 treemanifest: make node reuse match flat manifest behavior Durham Goode <durham@fb.com> parents: 31265 diff changeset	1913 n = m2.node()
c134a33b1d73 treemanifest: make node reuse match flat manifest behavior Durham Goode <durham@fb.com> parents: 31265 diff changeset	1914
c134a33b1d73 treemanifest: make node reuse match flat manifest behavior Durham Goode <durham@fb.com> parents: 31265 diff changeset	1915 if not n:
46560 f7b61ad3c64a revlog: change addrevision to return the new revision, not node Joerg Sonnenberger <joerg@bec.de> parents: 46445 diff changeset	1916 rev = self._revlog.addrevision(
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1917 text, transaction, link, m1.node(), m2.node()
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1918 )
46560 f7b61ad3c64a revlog: change addrevision to return the new revision, not node Joerg Sonnenberger <joerg@bec.de> parents: 46445 diff changeset	1919 n = self._revlog.node(rev)
31303 c134a33b1d73 treemanifest: make node reuse match flat manifest behavior Durham Goode <durham@fb.com> parents: 31265 diff changeset	1920
29965 774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1921 # Save nodeid so parent manifest can calculate its nodeid
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1922 m.setnode(n)
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1923 return n
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1924
39341 7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1925 def __len__(self):
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1926 return len(self._revlog)
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1927
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1928 def __iter__(self):
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1929 return self._revlog.__iter__()
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1930
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1931 def rev(self, node):
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1932 return self._revlog.rev(node)
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1933
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1934 def node(self, rev):
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1935 return self._revlog.node(rev)
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1936
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1937 def lookup(self, value):
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1938 return self._revlog.lookup(value)
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1939
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1940 def parentrevs(self, rev):
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1941 return self._revlog.parentrevs(rev)
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1942
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1943 def parents(self, node):
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1944 return self._revlog.parents(node)
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1945
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1946 def linkrev(self, rev):
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1947 return self._revlog.linkrev(rev)
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1948
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1949 def checksize(self):
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1950 return self._revlog.checksize()
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1951
51027 33d2f0164d0d revlog: drop the df argument to `revision` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 50952 diff changeset	1952 def revision(self, node):
33d2f0164d0d revlog: drop the df argument to `revision` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 50952 diff changeset	1953 return self._revlog.revision(node)
39341 7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1954
51028 14de15825253 revlog: drop the df argument to `rawdata` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51027 diff changeset	1955 def rawdata(self, node):
14de15825253 revlog: drop the df argument to `rawdata` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51027 diff changeset	1956 return self._revlog.rawdata(node)
42740 2128c76c8970 rawdata: forward `rawdata` call on `manifestlog` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42485 diff changeset	1957
39341 7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1958 def revdiff(self, rev1, rev2):
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1959 return self._revlog.revdiff(rev1, rev2)
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1960
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1961 def cmp(self, node, text):
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1962 return self._revlog.cmp(node, text)
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1963
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1964 def deltaparent(self, rev):
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1965 return self._revlog.deltaparent(rev)
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	1966
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1967 def emitrevisions(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1968 self,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1969 nodes,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1970 nodesorder=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1971 revisiondata=False,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1972 assumehaveparentrevisions=False,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1973 deltamode=repository.CG_DELTAMODE_STD,
46728 45f0d5297698 changegroupv4: add sidedata helpers Rapha?l Gom?s <rgomes@octobus.net> parents: 46727 diff changeset	1974 sidedata_helpers=None,
49738 9cac281eb9c0 debug: add an option to display statistic about a bundling operation Pierre-Yves David <pierre-yves.david@octobus.net> parents: 49234 diff changeset	1975 debug_info=None,
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1976 ):
39867 5a9ab91e0a45 revlog: new API to emit revision data Gregory Szorc <gregory.szorc@gmail.com> parents: 39863 diff changeset	1977 return self._revlog.emitrevisions(
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1978 nodes,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1979 nodesorder=nodesorder,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1980 revisiondata=revisiondata,
39867 5a9ab91e0a45 revlog: new API to emit revision data Gregory Szorc <gregory.szorc@gmail.com> parents: 39863 diff changeset	1981 assumehaveparentrevisions=assumehaveparentrevisions,
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1982 deltamode=deltamode,
46728 45f0d5297698 changegroupv4: add sidedata helpers Rapha?l Gom?s <rgomes@octobus.net> parents: 46727 diff changeset	1983 sidedata_helpers=sidedata_helpers,
49738 9cac281eb9c0 debug: add an option to display statistic about a bundling operation Pierre-Yves David <pierre-yves.david@octobus.net> parents: 49234 diff changeset	1984 debug_info=debug_info,
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1985 )
39867 5a9ab91e0a45 revlog: new API to emit revision data Gregory Szorc <gregory.szorc@gmail.com> parents: 39863 diff changeset	1986
45811 a5206e71c536 revlog: extend addgroup() with callback for duplicates Joerg Sonnenberger <joerg@bec.de> parents: 45253 diff changeset	1987 def addgroup(
a5206e71c536 revlog: extend addgroup() with callback for duplicates Joerg Sonnenberger <joerg@bec.de> parents: 45253 diff changeset	1988 self,
a5206e71c536 revlog: extend addgroup() with callback for duplicates Joerg Sonnenberger <joerg@bec.de> parents: 45253 diff changeset	1989 deltas,
a5206e71c536 revlog: extend addgroup() with callback for duplicates Joerg Sonnenberger <joerg@bec.de> parents: 45253 diff changeset	1990 linkmapper,
a5206e71c536 revlog: extend addgroup() with callback for duplicates Joerg Sonnenberger <joerg@bec.de> parents: 45253 diff changeset	1991 transaction,
46445 711ba0f1057e revlog: decouple caching from addrevision callback for addgroup Joerg Sonnenberger <joerg@bec.de> parents: 46247 diff changeset	1992 alwayscache=False,
45811 a5206e71c536 revlog: extend addgroup() with callback for duplicates Joerg Sonnenberger <joerg@bec.de> parents: 45253 diff changeset	1993 addrevisioncb=None,
a5206e71c536 revlog: extend addgroup() with callback for duplicates Joerg Sonnenberger <joerg@bec.de> parents: 45253 diff changeset	1994 duplicaterevisioncb=None,
49739 35d4c2124073 debug: add an option to display statistic about a unbundling operation Pierre-Yves David <pierre-yves.david@octobus.net> parents: 49738 diff changeset	1995 debug_info=None,
49877 152d9c011bcd changegroup: add `delta_base_reuse_policy` argument Pierre-Yves David <pierre-yves.david@octobus.net> parents: 49739 diff changeset	1996 delta_base_reuse_policy=None,
45811 a5206e71c536 revlog: extend addgroup() with callback for duplicates Joerg Sonnenberger <joerg@bec.de> parents: 45253 diff changeset	1997 ):
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	1998 return self._revlog.addgroup(
45811 a5206e71c536 revlog: extend addgroup() with callback for duplicates Joerg Sonnenberger <joerg@bec.de> parents: 45253 diff changeset	1999 deltas,
a5206e71c536 revlog: extend addgroup() with callback for duplicates Joerg Sonnenberger <joerg@bec.de> parents: 45253 diff changeset	2000 linkmapper,
a5206e71c536 revlog: extend addgroup() with callback for duplicates Joerg Sonnenberger <joerg@bec.de> parents: 45253 diff changeset	2001 transaction,
46445 711ba0f1057e revlog: decouple caching from addrevision callback for addgroup Joerg Sonnenberger <joerg@bec.de> parents: 46247 diff changeset	2002 alwayscache=alwayscache,
45811 a5206e71c536 revlog: extend addgroup() with callback for duplicates Joerg Sonnenberger <joerg@bec.de> parents: 45253 diff changeset	2003 addrevisioncb=addrevisioncb,
a5206e71c536 revlog: extend addgroup() with callback for duplicates Joerg Sonnenberger <joerg@bec.de> parents: 45253 diff changeset	2004 duplicaterevisioncb=duplicaterevisioncb,
49739 35d4c2124073 debug: add an option to display statistic about a unbundling operation Pierre-Yves David <pierre-yves.david@octobus.net> parents: 49738 diff changeset	2005 debug_info=debug_info,
49877 152d9c011bcd changegroup: add `delta_base_reuse_policy` argument Pierre-Yves David <pierre-yves.david@octobus.net> parents: 49739 diff changeset	2006 delta_base_reuse_policy=delta_base_reuse_policy,
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2007 )
39341 7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2008
39863 9534fe1e5d28 manifest: add rawsize() proxy (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 39793 diff changeset	2009 def rawsize(self, rev):
9534fe1e5d28 manifest: add rawsize() proxy (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 39793 diff changeset	2010 return self._revlog.rawsize(rev)
9534fe1e5d28 manifest: add rawsize() proxy (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 39793 diff changeset	2011
39341 7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2012 def getstrippoint(self, minlink):
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2013 return self._revlog.getstrippoint(minlink)
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2014
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2015 def strip(self, minlink, transaction):
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2016 return self._revlog.strip(minlink, transaction)
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2017
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2018 def files(self):
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2019 return self._revlog.files()
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2020
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2021 def clone(self, tr, destrevlog, **kwargs):
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2022 if not isinstance(destrevlog, manifestrevlog):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	2023 raise error.ProgrammingError(b'expected manifestrevlog to clone()')
39341 7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2024
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2025 return self._revlog.clone(tr, destrevlog._revlog, **kwargs)
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2026
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2027 def storageinfo(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2028 self,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2029 exclusivefiles=False,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2030 sharedfiles=False,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2031 revisionscount=False,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2032 trackedsize=False,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2033 storedsize=False,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2034 ):
39874 14e500b58263 revlog: add method for obtaining storage info (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 39871 diff changeset	2035 return self._revlog.storageinfo(
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2036 exclusivefiles=exclusivefiles,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2037 sharedfiles=sharedfiles,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2038 revisionscount=revisionscount,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2039 trackedsize=trackedsize,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2040 storedsize=storedsize,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2041 )
39874 14e500b58263 revlog: add method for obtaining storage info (API) Gregory Szorc <gregory.szorc@gmail.com> parents: 39871 diff changeset	2042
39341 7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2043 @property
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2044 def opener(self):
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2045 return self._revlog.opener
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2046
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2047 @opener.setter
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2048 def opener(self, value):
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2049 self._revlog.opener = value
7f5e6d3e9032 manifest: proxy to revlog instance instead of inheriting Gregory Szorc <gregory.szorc@gmail.com> parents: 39274 diff changeset	2050
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2051
52098 33f255bf19d9 manifest: drop the CamelCase name for `manifest.treemanifestctx` Matt Harbison <matt_harbison@yahoo.com> parents: 52097 diff changeset	2052 # TODO: drop this in favor of repository.imanifestrevisionstored?
33f255bf19d9 manifest: drop the CamelCase name for `manifest.treemanifestctx` Matt Harbison <matt_harbison@yahoo.com> parents: 52097 diff changeset	2053 AnyManifestCtx = Union['manifestctx', 'treemanifestctx']
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	2054 # TODO: drop this in favor of repository.imanifestdict
c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	2055 AnyManifestDict = Union[manifestdict, treemanifest]
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	2056
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	2057
52513 d371efa7c358 manifest: subclass the new `repository.imanifestlog` Protocol class Matt Harbison <matt_harbison@yahoo.com> parents: 52510 diff changeset	2058 class manifestlog(repository.imanifestlog):
29836 426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	2059 """A collection class representing the collection of manifest snapshots
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	2060 referenced by commits in the repository.
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	2061
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	2062 In this situation, 'manifest' refers to the abstract concept of a snapshot
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	2063 of the list of files in the given commit. Consumers of the output of this
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	2064 class do not care about the implementation details of the actual manifests
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	2065 they receive (i.e. tree or flat or lazily loaded, etc)."""
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2066
41041 3913223417ea manifest: accept narrowmatch into constructor instead of getting from repo Martin von Zweigbergk <martinvonz@google.com> parents: 40496 diff changeset	2067 def __init__(self, opener, repo, rootstore, narrowmatch):
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	2068 self.nodeconstants = repo.nodeconstants
29963 483003c27938 manifest: move treeinmem onto manifestlog Durham Goode <durham@fb.com> parents: 29945 diff changeset	2069 usetreemanifest = False
30382 7c7d845f8b64 manifest: make manifestlog use it's own cache Durham Goode <durham@fb.com> parents: 30381 diff changeset	2070 cachesize = 4
29963 483003c27938 manifest: move treeinmem onto manifestlog Durham Goode <durham@fb.com> parents: 29945 diff changeset	2071
483003c27938 manifest: move treeinmem onto manifestlog Durham Goode <durham@fb.com> parents: 29945 diff changeset	2072 opts = getattr(opener, 'options', None)
483003c27938 manifest: move treeinmem onto manifestlog Durham Goode <durham@fb.com> parents: 29945 diff changeset	2073 if opts is not None:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	2074 usetreemanifest = opts.get(b'treemanifest', usetreemanifest)
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	2075 cachesize = opts.get(b'manifestcachesize', cachesize)
39273 071f97d03acb manifest: rename manifestlog._treeinmem to ._treemanifests Gregory Szorc <gregory.szorc@gmail.com> parents: 39272 diff changeset	2076
071f97d03acb manifest: rename manifestlog._treeinmem to ._treemanifests Gregory Szorc <gregory.szorc@gmail.com> parents: 39272 diff changeset	2077 self._treemanifests = usetreemanifest
29963 483003c27938 manifest: move treeinmem onto manifestlog Durham Goode <durham@fb.com> parents: 29945 diff changeset	2078
39779 5ccd791344f3 localrepo: pass root manifest into manifestlog.__init__ Gregory Szorc <gregory.szorc@gmail.com> parents: 39684 diff changeset	2079 self._rootstore = rootstore
39348 52860f52ed13 manifest: rename manifestlog._revlog to _rootstore Gregory Szorc <gregory.szorc@gmail.com> parents: 39347 diff changeset	2080 self._rootstore._setupmanifestcachehooks(repo)
41041 3913223417ea manifest: accept narrowmatch into constructor instead of getting from repo Martin von Zweigbergk <martinvonz@google.com> parents: 40496 diff changeset	2081 self._narrowmatch = narrowmatch
30219 3c8811efdddc manifest: make manifestlog a storecache Durham Goode <durham@fb.com> parents: 30209 diff changeset	2082
30306 d4b340bf68c5 manifest: change manifestlog mancache to be directory based Durham Goode <durham@fb.com> parents: 30305 diff changeset	2083 # A cache of the manifestctx or treemanifestctx for each directory
d4b340bf68c5 manifest: change manifestlog mancache to be directory based Durham Goode <durham@fb.com> parents: 30305 diff changeset	2084 self._dirmancache = {}
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	2085 self._dirmancache[b''] = util.lrucachedict(cachesize)
30306 d4b340bf68c5 manifest: change manifestlog mancache to be directory based Durham Goode <durham@fb.com> parents: 30305 diff changeset	2086
38514 561a450c7b64 manifest: make cachesize a private attribute Gregory Szorc <gregory.szorc@gmail.com> parents: 38340 diff changeset	2087 self._cachesize = cachesize
29837 93b44aa17691 manifest: use property instead of field for manifest revlog storage Durham Goode <durham@fb.com> parents: 29836 diff changeset	2088
29836 426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	2089 def __getitem__(self, node):
30304 1a0c1ad57833 manifest: throw LookupError if node not in revlog Durham Goode <durham@fb.com> parents: 30221 diff changeset	2090 """Retrieves the manifest instance for the given node. Throws a
1a0c1ad57833 manifest: throw LookupError if node not in revlog Durham Goode <durham@fb.com> parents: 30221 diff changeset	2091 LookupError if not found.
29836 426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	2092 """
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	2093 return self.get(b'', node)
29836 426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	2094
51837 bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2095 @property
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2096 def narrowed(self):
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2097 return not (self._narrowmatch is None or self._narrowmatch.always())
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2098
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	2099 def get(
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	2100 self, tree: bytes, node: bytes, verify: bool = True
79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	2101 ) -> AnyManifestCtx:
30305 dc21ea3323c4 manifest: add manifestlog.get to obtain subdirectory instances Durham Goode <durham@fb.com> parents: 30304 diff changeset	2102 """Retrieves the manifest instance for the given node. Throws a
dc21ea3323c4 manifest: add manifestlog.get to obtain subdirectory instances Durham Goode <durham@fb.com> parents: 30304 diff changeset	2103 LookupError if not found.
30413 a431daa93f8c manifest: make revlog verification optional Durham Goode <durham@fb.com> parents: 30387 diff changeset	2104
a431daa93f8c manifest: make revlog verification optional Durham Goode <durham@fb.com> parents: 30387 diff changeset	2105 `verify` - if True an exception will be thrown if the node is not in
a431daa93f8c manifest: make revlog verification optional Durham Goode <durham@fb.com> parents: 30387 diff changeset	2106 the revlog
30305 dc21ea3323c4 manifest: add manifestlog.get to obtain subdirectory instances Durham Goode <durham@fb.com> parents: 30304 diff changeset	2107 """
39263 43387fd2aa1f manifest: rename dir to tree to avoid shadowing built-in Gregory Szorc <gregory.szorc@gmail.com> parents: 38821 diff changeset	2108 if node in self._dirmancache.get(tree, ()):
43387fd2aa1f manifest: rename dir to tree to avoid shadowing built-in Gregory Szorc <gregory.szorc@gmail.com> parents: 38821 diff changeset	2109 return self._dirmancache[tree][node]
30306 d4b340bf68c5 manifest: change manifestlog mancache to be directory based Durham Goode <durham@fb.com> parents: 30305 diff changeset	2110
37374 ac42e39b1b77 narrow: move manifestlog overrides to core Martin von Zweigbergk <martinvonz@google.com> parents: 37373 diff changeset	2111 if not self._narrowmatch.always():
42363 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41970 diff changeset	2112 if not self._narrowmatch.visitdir(tree[:-1]):
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	2113 return excludeddirmanifestctx(self.nodeconstants, tree, node)
39263 43387fd2aa1f manifest: rename dir to tree to avoid shadowing built-in Gregory Szorc <gregory.szorc@gmail.com> parents: 38821 diff changeset	2114 if tree:
39348 52860f52ed13 manifest: rename manifestlog._revlog to _rootstore Gregory Szorc <gregory.szorc@gmail.com> parents: 39347 diff changeset	2115 if self._rootstore._treeondisk:
30413 a431daa93f8c manifest: make revlog verification optional Durham Goode <durham@fb.com> parents: 30387 diff changeset	2116 if verify:
39274 61700d525a3b manifest: use rev() instead of nodemap.__contains__ Gregory Szorc <gregory.szorc@gmail.com> parents: 39273 diff changeset	2117 # Side-effect is LookupError is raised if node doesn't
61700d525a3b manifest: use rev() instead of nodemap.__contains__ Gregory Szorc <gregory.szorc@gmail.com> parents: 39273 diff changeset	2118 # exist.
61700d525a3b manifest: use rev() instead of nodemap.__contains__ Gregory Szorc <gregory.szorc@gmail.com> parents: 39273 diff changeset	2119 self.getstorage(tree).rev(node)
61700d525a3b manifest: use rev() instead of nodemap.__contains__ Gregory Szorc <gregory.szorc@gmail.com> parents: 39273 diff changeset	2120
39263 43387fd2aa1f manifest: rename dir to tree to avoid shadowing built-in Gregory Szorc <gregory.szorc@gmail.com> parents: 38821 diff changeset	2121 m = treemanifestctx(self, tree, node)
30305 dc21ea3323c4 manifest: add manifestlog.get to obtain subdirectory instances Durham Goode <durham@fb.com> parents: 30304 diff changeset	2122 else:
dc21ea3323c4 manifest: add manifestlog.get to obtain subdirectory instances Durham Goode <durham@fb.com> parents: 30304 diff changeset	2123 raise error.Abort(
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2124 _(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	2125 b"cannot ask for manifest directory '%s' in a flat "
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	2126 b"manifest"
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2127 )
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2128 % tree
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2129 )
29911 4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	2130 else:
30413 a431daa93f8c manifest: make revlog verification optional Durham Goode <durham@fb.com> parents: 30387 diff changeset	2131 if verify:
39274 61700d525a3b manifest: use rev() instead of nodemap.__contains__ Gregory Szorc <gregory.szorc@gmail.com> parents: 39273 diff changeset	2132 # Side-effect is LookupError is raised if node doesn't exist.
39348 52860f52ed13 manifest: rename manifestlog._revlog to _rootstore Gregory Szorc <gregory.szorc@gmail.com> parents: 39347 diff changeset	2133 self._rootstore.rev(node)
39274 61700d525a3b manifest: use rev() instead of nodemap.__contains__ Gregory Szorc <gregory.szorc@gmail.com> parents: 39273 diff changeset	2134
39273 071f97d03acb manifest: rename manifestlog._treeinmem to ._treemanifests Gregory Szorc <gregory.szorc@gmail.com> parents: 39272 diff changeset	2135 if self._treemanifests:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	2136 m = treemanifestctx(self, b'', node)
30305 dc21ea3323c4 manifest: add manifestlog.get to obtain subdirectory instances Durham Goode <durham@fb.com> parents: 30304 diff changeset	2137 else:
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	2138 m = manifestctx(self, node)
30306 d4b340bf68c5 manifest: change manifestlog mancache to be directory based Durham Goode <durham@fb.com> parents: 30305 diff changeset	2139
47055 d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	2140 if node != self.nodeconstants.nullid:
39263 43387fd2aa1f manifest: rename dir to tree to avoid shadowing built-in Gregory Szorc <gregory.szorc@gmail.com> parents: 38821 diff changeset	2141 mancache = self._dirmancache.get(tree)
30306 d4b340bf68c5 manifest: change manifestlog mancache to be directory based Durham Goode <durham@fb.com> parents: 30305 diff changeset	2142 if not mancache:
38514 561a450c7b64 manifest: make cachesize a private attribute Gregory Szorc <gregory.szorc@gmail.com> parents: 38340 diff changeset	2143 mancache = util.lrucachedict(self._cachesize)
39263 43387fd2aa1f manifest: rename dir to tree to avoid shadowing built-in Gregory Szorc <gregory.szorc@gmail.com> parents: 38821 diff changeset	2144 self._dirmancache[tree] = mancache
30306 d4b340bf68c5 manifest: change manifestlog mancache to be directory based Durham Goode <durham@fb.com> parents: 30305 diff changeset	2145 mancache[node] = m
29836 426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	2146 return m
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	2147
39272 73cf21b2e8a6 manifest: add getstorage() to manifestlog and use it globally Gregory Szorc <gregory.szorc@gmail.com> parents: 39271 diff changeset	2148 def getstorage(self, tree):
39348 52860f52ed13 manifest: rename manifestlog._revlog to _rootstore Gregory Szorc <gregory.szorc@gmail.com> parents: 39347 diff changeset	2149 return self._rootstore.dirlog(tree)
39272 73cf21b2e8a6 manifest: add getstorage() to manifestlog and use it globally Gregory Szorc <gregory.szorc@gmail.com> parents: 39271 diff changeset	2150
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	2151 def clearcaches(self, clear_persisted_data: bool = False) -> None:
30380 10c924596e5c manifest: move clearcaches to manifestlog Durham Goode <durham@fb.com> parents: 30379 diff changeset	2152 self._dirmancache.clear()
39348 52860f52ed13 manifest: rename manifestlog._revlog to _rootstore Gregory Szorc <gregory.szorc@gmail.com> parents: 39347 diff changeset	2153 self._rootstore.clearcaches(clear_persisted_data=clear_persisted_data)
30380 10c924596e5c manifest: move clearcaches to manifestlog Durham Goode <durham@fb.com> parents: 30379 diff changeset	2154
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	2155 def rev(self, node) -> int:
39348 52860f52ed13 manifest: rename manifestlog._revlog to _rootstore Gregory Szorc <gregory.szorc@gmail.com> parents: 39347 diff changeset	2156 return self._rootstore.rev(node)
38556 f2f9bacf0587 manifest: define and implement rev() on manifestlog Gregory Szorc <gregory.szorc@gmail.com> parents: 38532 diff changeset	2157
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	2158 def update_caches(self, transaction) -> None:
44864 97ebdb192b00 nodemap: also warm manifest nodemap with other caches Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44863 diff changeset	2159 return self._rootstore._revlog.update_caches(transaction=transaction)
97ebdb192b00 nodemap: also warm manifest nodemap with other caches Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44863 diff changeset	2160
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2161
52095 3f47f0d92b4a manifest: drop the CamelCase name for `manifest.memmanifestctx` Matt Harbison <matt_harbison@yahoo.com> parents: 52094 diff changeset	2162 class memmanifestctx: # (repository.imanifestrevisionwritable)
52091 35400ce47b64 manifest: drop the CamelCase name for `manifest.manifestdict` Matt Harbison <matt_harbison@yahoo.com> parents: 51909 diff changeset	2163 _manifestdict: manifestdict
51868 0338fb200a30 typing: lock in new pytype gains from making revlog related classes typeable Matt Harbison <matt_harbison@yahoo.com> parents: 51865 diff changeset	2164
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	2165 def __init__(self, manifestlog):
5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	2166 self._manifestlog = manifestlog
47083 12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	2167 self._manifestdict = manifestdict(manifestlog.nodeconstants.nodelen)
30352 fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	2168
52093 4675ab746a02 manifest: drop the CamelCase name for `manifest.manifestrevlog` Matt Harbison <matt_harbison@yahoo.com> parents: 52092 diff changeset	2169 def _storage(self) -> manifestrevlog:
39347 57301ba47e66 manifest: use public API for obtaining storage object Gregory Szorc <gregory.szorc@gmail.com> parents: 39344 diff changeset	2170 return self._manifestlog.getstorage(b'')
30355 fa54f7ade491 manifest: remove manifest.add and add memmfctx.write Durham Goode <durham@fb.com> parents: 30353 diff changeset	2171
52095 3f47f0d92b4a manifest: drop the CamelCase name for `manifest.memmanifestctx` Matt Harbison <matt_harbison@yahoo.com> parents: 52094 diff changeset	2172 def copy(self) -> 'memmanifestctx':
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	2173 memmf = memmanifestctx(self._manifestlog)
30353 952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	2174 memmf._manifestdict = self.read().copy()
952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	2175 return memmf
952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	2176
52091 35400ce47b64 manifest: drop the CamelCase name for `manifest.manifestdict` Matt Harbison <matt_harbison@yahoo.com> parents: 51909 diff changeset	2177 def read(self) -> 'manifestdict':
30352 fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	2178 return self._manifestdict
fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	2179
39684 24870f1be088 narrow: when writing treemanifests, skip inspecting directories outside narrow spectral <spectral@google.com> parents: 39539 diff changeset	2180 def write(self, transaction, link, p1, p2, added, removed, match=None):
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2181 return self._storage().add(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2182 self._manifestdict,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2183 transaction,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2184 link,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2185 p1,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2186 p2,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2187 added,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2188 removed,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2189 match=match,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2190 )
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2191
30355 fa54f7ade491 manifest: remove manifest.add and add memmfctx.write Durham Goode <durham@fb.com> parents: 30353 diff changeset	2192
52506 d37d8dfe65bd manifest: subclass the new `repository.imanifestrevisionstored` Protocol class Matt Harbison <matt_harbison@yahoo.com> parents: 52503 diff changeset	2193 class manifestctx(repository.imanifestrevisionstored):
29836 426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	2194 """A class representing a single revision of a manifest, including its
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	2195 contents, its parent revs, and its linkrev.
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	2196 """
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2197
52091 35400ce47b64 manifest: drop the CamelCase name for `manifest.manifestdict` Matt Harbison <matt_harbison@yahoo.com> parents: 51909 diff changeset	2198 _data: Optional[manifestdict]
51868 0338fb200a30 typing: lock in new pytype gains from making revlog related classes typeable Matt Harbison <matt_harbison@yahoo.com> parents: 51865 diff changeset	2199
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	2200 def __init__(self, manifestlog, node):
5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	2201 self._manifestlog = manifestlog
29930 be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	2202 self._data = None
29836 426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	2203
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	2204 self._node = node
29911 4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	2205
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	2206 # TODO: We eventually want p1, p2, and linkrev exposed on this class,
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	2207 # but let's add it later when something needs it and we can load it
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	2208 # lazily.
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2209 # self.p1, self.p2 = store.parents(node)
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2210 # rev = store.rev(node)
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2211 # self.linkrev = store.linkrev(rev)
29836 426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	2212
52093 4675ab746a02 manifest: drop the CamelCase name for `manifest.manifestrevlog` Matt Harbison <matt_harbison@yahoo.com> parents: 52092 diff changeset	2213 def _storage(self) -> 'manifestrevlog':
39347 57301ba47e66 manifest: use public API for obtaining storage object Gregory Szorc <gregory.szorc@gmail.com> parents: 39344 diff changeset	2214 return self._manifestlog.getstorage(b'')
30351 3dfb5a0171c9 manifestctx: add _revlog() function Durham Goode <durham@fb.com> parents: 30350 diff changeset	2215
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	2216 def node(self) -> bytes:
29836 426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	2217 return self._node
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	2218
52095 3f47f0d92b4a manifest: drop the CamelCase name for `manifest.memmanifestctx` Matt Harbison <matt_harbison@yahoo.com> parents: 52094 diff changeset	2219 def copy(self) -> memmanifestctx:
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	2220 memmf = memmanifestctx(self._manifestlog)
30353 952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	2221 memmf._manifestdict = self.read().copy()
952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	2222 return memmf
952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	2223
30570 7fbc8a742b4d manifest: expose the parents() method Mateusz Kwapich <mitrandir@fb.com> parents: 30452 diff changeset	2224 @propertycache
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	2225 def parents(self) -> Tuple[bytes, bytes]:
39344 eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2226 return self._storage().parents(self._node)
30570 7fbc8a742b4d manifest: expose the parents() method Mateusz Kwapich <mitrandir@fb.com> parents: 30452 diff changeset	2227
52091 35400ce47b64 manifest: drop the CamelCase name for `manifest.manifestdict` Matt Harbison <matt_harbison@yahoo.com> parents: 51909 diff changeset	2228 def read(self) -> 'manifestdict':
31114 4a1486c73fdf manifest: check 'if x is None' instead of 'if not x' Durham Goode <durham@fb.com> parents: 30570 diff changeset	2229 if self._data is None:
47083 12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	2230 nc = self._manifestlog.nodeconstants
12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	2231 if self._node == nc.nullid:
12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	2232 self._data = manifestdict(nc.nodelen)
29930 be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	2233 else:
39344 eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2234 store = self._storage()
39349 5886384d1ac5 manifest: use fulltextcache instead of _fulltextcache Gregory Szorc <gregory.szorc@gmail.com> parents: 39348 diff changeset	2235 if self._node in store.fulltextcache:
5886384d1ac5 manifest: use fulltextcache instead of _fulltextcache Gregory Szorc <gregory.szorc@gmail.com> parents: 39348 diff changeset	2236 text = pycompat.bytestr(store.fulltextcache[self._node])
38821 0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	2237 else:
39344 eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2238 text = store.revision(self._node)
38821 0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	2239 arraytext = bytearray(text)
39349 5886384d1ac5 manifest: use fulltextcache instead of _fulltextcache Gregory Szorc <gregory.szorc@gmail.com> parents: 39348 diff changeset	2240 store.fulltextcache[self._node] = arraytext
47083 12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	2241 self._data = manifestdict(nc.nodelen, text)
29930 be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	2242 return self._data
be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	2243
52091 35400ce47b64 manifest: drop the CamelCase name for `manifest.manifestdict` Matt Harbison <matt_harbison@yahoo.com> parents: 51909 diff changeset	2244 def readfast(self, shallow: bool = False) -> 'manifestdict':
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	2245 """Calls either readdelta or read, based on which would be less work.
30308 bce79dfcf5e4 manifest: get rid of manifest.readshallowfast Durham Goode <durham@fb.com> parents: 30307 diff changeset	2246 readdelta is called if the delta is against the p1, and therefore can be
bce79dfcf5e4 manifest: get rid of manifest.readshallowfast Durham Goode <durham@fb.com> parents: 30307 diff changeset	2247 read quickly.
bce79dfcf5e4 manifest: get rid of manifest.readshallowfast Durham Goode <durham@fb.com> parents: 30307 diff changeset	2248
bce79dfcf5e4 manifest: get rid of manifest.readshallowfast Durham Goode <durham@fb.com> parents: 30307 diff changeset	2249 If `shallow` is True, nothing changes since this is a flat manifest.
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	2250 """
51840 9af1acc1ffab manifest: deprecated readdelta and readfast Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51837 diff changeset	2251 util.nouideprecwarn(
9af1acc1ffab manifest: deprecated readdelta and readfast Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51837 diff changeset	2252 b'"readfast" is deprecated use "read_any_fast_delta" or "read_delta_parents"',
9af1acc1ffab manifest: deprecated readdelta and readfast Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51837 diff changeset	2253 b"6.9",
9af1acc1ffab manifest: deprecated readdelta and readfast Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51837 diff changeset	2254 stacklevel=2,
9af1acc1ffab manifest: deprecated readdelta and readfast Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51837 diff changeset	2255 )
39344 eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2256 store = self._storage()
eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2257 r = store.rev(self._node)
eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2258 deltaparent = store.deltaparent(r)
eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2259 if deltaparent != nullrev and deltaparent in store.parentrevs(r):
29943 80be4436e4cc manifest: adds manifestctx.readfast Durham Goode <durham@fb.com> parents: 29942 diff changeset	2260 return self.readdelta()
80be4436e4cc manifest: adds manifestctx.readfast Durham Goode <durham@fb.com> parents: 29942 diff changeset	2261 return self.read()
80be4436e4cc manifest: adds manifestctx.readfast Durham Goode <durham@fb.com> parents: 29942 diff changeset	2262
52091 35400ce47b64 manifest: drop the CamelCase name for `manifest.manifestdict` Matt Harbison <matt_harbison@yahoo.com> parents: 51909 diff changeset	2263 def readdelta(self, shallow: bool = False) -> 'manifestdict':
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	2264 """Returns a manifest containing just the entries that are present
30309 f65faa4422c8 manifest: remove manifest.readshallowdelta Durham Goode <durham@fb.com> parents: 30308 diff changeset	2265 in this manifest, but not in its p1 manifest. This is efficient to read
f65faa4422c8 manifest: remove manifest.readshallowdelta Durham Goode <durham@fb.com> parents: 30308 diff changeset	2266 if the revlog delta is already p1.
f65faa4422c8 manifest: remove manifest.readshallowdelta Durham Goode <durham@fb.com> parents: 30308 diff changeset	2267
f65faa4422c8 manifest: remove manifest.readshallowdelta Durham Goode <durham@fb.com> parents: 30308 diff changeset	2268 Changing the value of `shallow` has no effect on flat manifests.
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	2269 """
51840 9af1acc1ffab manifest: deprecated readdelta and readfast Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51837 diff changeset	2270 util.nouideprecwarn(
9af1acc1ffab manifest: deprecated readdelta and readfast Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51837 diff changeset	2271 b'"readfast" is deprecated use "read_any_fast_delta" or "read_delta_new_entries"',
9af1acc1ffab manifest: deprecated readdelta and readfast Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51837 diff changeset	2272 b"6.9",
9af1acc1ffab manifest: deprecated readdelta and readfast Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51837 diff changeset	2273 stacklevel=2,
9af1acc1ffab manifest: deprecated readdelta and readfast Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51837 diff changeset	2274 )
39344 eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2275 store = self._storage()
eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2276 r = store.rev(self._node)
eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2277 d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r))
47083 12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	2278 return manifestdict(store.nodeconstants.nodelen, d)
29942 a059b17352ef manifest: add manifestctx.readdelta() Durham Goode <durham@fb.com> parents: 29930 diff changeset	2279
51827 ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2280 def read_any_fast_delta(
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2281 self,
51828 e1fd715df257 manifest: allow skipping valid_bases argument to `read_any_fast_delta` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51827 diff changeset	2282 valid_bases: Optional[Collection[int]] = None,
51827 ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2283 *,
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2284 shallow: bool = False,
52091 35400ce47b64 manifest: drop the CamelCase name for `manifest.manifestdict` Matt Harbison <matt_harbison@yahoo.com> parents: 51909 diff changeset	2285 ) -> Tuple[Optional[int], manifestdict]:
51827 ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2286 """see `imanifestrevisionstored` documentation"""
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2287 store = self._storage()
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2288 r = store.rev(self._node)
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2289 deltaparent = store.deltaparent(r)
51828 e1fd715df257 manifest: allow skipping valid_bases argument to `read_any_fast_delta` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51827 diff changeset	2290 if valid_bases is None:
e1fd715df257 manifest: allow skipping valid_bases argument to `read_any_fast_delta` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51827 diff changeset	2291 # make sure the next check is True
e1fd715df257 manifest: allow skipping valid_bases argument to `read_any_fast_delta` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51827 diff changeset	2292 valid_bases = (deltaparent,)
51827 ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2293 if deltaparent != nullrev and deltaparent in valid_bases:
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2294 d = mdiff.patchtext(store.revdiff(deltaparent, r))
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2295 return (
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2296 deltaparent,
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2297 manifestdict(store.nodeconstants.nodelen, d),
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2298 )
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2299 return (None, self.read())
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2300
51833 a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2301 def read_delta_parents(
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2302 self,
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2303 *,
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2304 shallow: bool = False,
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2305 exact: bool = True,
52091 35400ce47b64 manifest: drop the CamelCase name for `manifest.manifestdict` Matt Harbison <matt_harbison@yahoo.com> parents: 51909 diff changeset	2306 ) -> manifestdict:
51833 a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2307 """see `interface.imanifestrevisionbase` documentations"""
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2308 store = self._storage()
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2309 r = store.rev(self._node)
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2310 deltaparent = store.deltaparent(r)
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2311 parents = [p for p in store.parentrevs(r) if p is not nullrev]
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2312 if not exact and deltaparent in parents:
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2313 d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r))
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2314 return manifestdict(store.nodeconstants.nodelen, d)
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2315 elif not exact or len(parents) == 0:
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2316 return self.read()
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2317 elif len(parents) == 1:
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2318 p = parents[0]
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2319 d = mdiff.patchtext(store.revdiff(p, r))
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2320 return manifestdict(store.nodeconstants.nodelen, d)
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2321 else:
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2322 p1, p2 = parents
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2323 d1 = mdiff.patchtext(store.revdiff(p1, r))
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2324 d2 = mdiff.patchtext(store.revdiff(p2, r))
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2325 d1 = manifestdict(store.nodeconstants.nodelen, d1)
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2326 d2 = manifestdict(store.nodeconstants.nodelen, d2)
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2327 md = manifestdict(store.nodeconstants.nodelen)
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2328 for f, new_node, new_flag in d1.iterentries():
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2329 if f not in d2:
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2330 continue
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2331 if new_node is not None:
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2332 md.set(f, new_node, new_flag)
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2333 return md
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2334
52503 048c11993d6a typing: (mostly) align the signatures of `imanifestrevisionstored` overrides Matt Harbison <matt_harbison@yahoo.com> parents: 52250 diff changeset	2335 def read_delta_new_entries(self, *, shallow: bool = False) -> manifestdict:
51837 bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2336 """see `interface.imanifestrevisionbase` documentations"""
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2337 # If we are using narrow, returning a delta against an arbitrary
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2338 # changeset might return file outside the narrowspec. This can create
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2339 # issue when running validation server side with strict security as
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2340 # push from low priviledge usage might be seen as adding new revision
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2341 # for files they cannot touch. So we are strict if narrow is involved.
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2342 if self._manifestlog.narrowed:
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2343 return self.read_delta_parents(shallow=shallow, exact=True)
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2344 store = self._storage()
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2345 r = store.rev(self._node)
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2346 d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r))
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2347 return manifestdict(store.nodeconstants.nodelen, d)
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2348
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	2349 def find(self, key: bytes) -> Tuple[bytes, bytes]:
30350 608ba935e041 manifest: remove manifest.find Durham Goode <durham@fb.com> parents: 30348 diff changeset	2350 return self.read().find(key)
608ba935e041 manifest: remove manifest.find Durham Goode <durham@fb.com> parents: 30348 diff changeset	2351
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2352
52510 22f97aa5e8b2 manifest: subclass the new `imanifestrevisionwritable` Protocol class Matt Harbison <matt_harbison@yahoo.com> parents: 52506 diff changeset	2353 class memtreemanifestctx(repository.imanifestrevisionwritable):
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	2354 _treemanifest: treemanifest
51868 0338fb200a30 typing: lock in new pytype gains from making revlog related classes typeable Matt Harbison <matt_harbison@yahoo.com> parents: 51865 diff changeset	2355
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	2356 def __init__(self, manifestlog, dir=b''):
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	2357 self._manifestlog = manifestlog
30352 fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	2358 self._dir = dir
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	2359 self._treemanifest = treemanifest(manifestlog.nodeconstants)
30352 fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	2360
52093 4675ab746a02 manifest: drop the CamelCase name for `manifest.manifestrevlog` Matt Harbison <matt_harbison@yahoo.com> parents: 52092 diff changeset	2361 def _storage(self) -> manifestrevlog:
39347 57301ba47e66 manifest: use public API for obtaining storage object Gregory Szorc <gregory.szorc@gmail.com> parents: 39344 diff changeset	2362 return self._manifestlog.getstorage(b'')
30355 fa54f7ade491 manifest: remove manifest.add and add memmfctx.write Durham Goode <durham@fb.com> parents: 30353 diff changeset	2363
52097 569e074894fa manifest: drop the CamelCase name for `manifest.memtreemanifestctx` Matt Harbison <matt_harbison@yahoo.com> parents: 52096 diff changeset	2364 def copy(self) -> 'memtreemanifestctx':
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	2365 memmf = memtreemanifestctx(self._manifestlog, dir=self._dir)
30353 952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	2366 memmf._treemanifest = self._treemanifest.copy()
952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	2367 return memmf
952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	2368
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	2369 def read(self) -> 'treemanifest':
30352 fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	2370 return self._treemanifest
fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	2371
39684 24870f1be088 narrow: when writing treemanifests, skip inspecting directories outside narrow spectral <spectral@google.com> parents: 39539 diff changeset	2372 def write(self, transaction, link, p1, p2, added, removed, match=None):
30378 ed45283a0ca7 manifest: remove dependency on manifestrevlog being able to create trees Durham Goode <durham@fb.com> parents: 30355 diff changeset	2373 def readtree(dir, node):
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	2374 return self._manifestlog.get(dir, node).read()
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2375
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2376 return self._storage().add(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2377 self._treemanifest,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2378 transaction,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2379 link,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2380 p1,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2381 p2,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2382 added,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2383 removed,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2384 readtree=readtree,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2385 match=match,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2386 )
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2387
30355 fa54f7ade491 manifest: remove manifest.add and add memmfctx.write Durham Goode <durham@fb.com> parents: 30353 diff changeset	2388
52506 d37d8dfe65bd manifest: subclass the new `repository.imanifestrevisionstored` Protocol class Matt Harbison <matt_harbison@yahoo.com> parents: 52503 diff changeset	2389 class treemanifestctx(repository.imanifestrevisionstored):
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	2390 _data: Optional[treemanifest]
51868 0338fb200a30 typing: lock in new pytype gains from making revlog related classes typeable Matt Harbison <matt_harbison@yahoo.com> parents: 51865 diff changeset	2391
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	2392 def __init__(self, manifestlog, dir, node):
5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	2393 self._manifestlog = manifestlog
29911 4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	2394 self._dir = dir
29930 be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	2395 self._data = None
29911 4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	2396
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	2397 self._node = node
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	2398
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	2399 # TODO: Load p1/p2/linkrev lazily. They need to be lazily loaded so that
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	2400 # we can instantiate treemanifestctx objects for directories we don't
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	2401 # have on disk.
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2402 # self.p1, self.p2 = store.parents(node)
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2403 # rev = store.rev(node)
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2404 # self.linkrev = store.linkrev(rev)
29911 4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	2405
52093 4675ab746a02 manifest: drop the CamelCase name for `manifest.manifestrevlog` Matt Harbison <matt_harbison@yahoo.com> parents: 52092 diff changeset	2406 def _storage(self) -> manifestrevlog:
37373 c50078fc32f3 narrow: move manifestrevlog overrides to core Martin von Zweigbergk <martinvonz@google.com> parents: 37372 diff changeset	2407 narrowmatch = self._manifestlog._narrowmatch
c50078fc32f3 narrow: move manifestrevlog overrides to core Martin von Zweigbergk <martinvonz@google.com> parents: 37372 diff changeset	2408 if not narrowmatch.always():
42363 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41970 diff changeset	2409 if not narrowmatch.visitdir(self._dir[:-1]):
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	2410 return excludedmanifestrevlog(
6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	2411 self._manifestlog.nodeconstants, self._dir
6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	2412 )
39272 73cf21b2e8a6 manifest: add getstorage() to manifestlog and use it globally Gregory Szorc <gregory.szorc@gmail.com> parents: 39271 diff changeset	2413 return self._manifestlog.getstorage(self._dir)
30221 f2c5b9d48b29 manifest: make treemanifestctx store the repo Durham Goode <durham@fb.com> parents: 30220 diff changeset	2414
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	2415 def read(self) -> 'treemanifest':
31114 4a1486c73fdf manifest: check 'if x is None' instead of 'if not x' Durham Goode <durham@fb.com> parents: 30570 diff changeset	2416 if self._data is None:
39344 eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2417 store = self._storage()
47055 d55b71393907 node: replace nullid and friends with nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46819 diff changeset	2418 if self._node == self._manifestlog.nodeconstants.nullid:
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	2419 self._data = treemanifest(self._manifestlog.nodeconstants)
39344 eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2420 # TODO accessing non-public API
eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2421 elif store._treeondisk:
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	2422 m = treemanifest(self._manifestlog.nodeconstants, dir=self._dir)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2423
29930 be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	2424 def gettext():
39344 eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2425 return store.revision(self._node)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2426
29930 be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	2427 def readsubtree(dir, subm):
30414 a1beadaa4061 manifest: change treemanifestctx to construct subtrees from the manifestlog Durham Goode <durham@fb.com> parents: 30413 diff changeset	2428 # Set verify to False since we need to be able to create
a1beadaa4061 manifest: change treemanifestctx to construct subtrees from the manifestlog Durham Goode <durham@fb.com> parents: 30413 diff changeset	2429 # subtrees for trees that don't exist on disk.
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	2430 return self._manifestlog.get(dir, subm, verify=False).read()
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2431
29930 be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	2432 m.read(gettext, readsubtree)
be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	2433 m.setnode(self._node)
be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	2434 self._data = m
be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	2435 else:
39344 eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2436 if self._node in store.fulltextcache:
eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2437 text = pycompat.bytestr(store.fulltextcache[self._node])
38821 0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	2438 else:
39344 eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2439 text = store.revision(self._node)
38821 0a57945aaf7f manifest: persist the manifestfulltext cache Martijn Pieters <mj@zopatista.com> parents: 38657 diff changeset	2440 arraytext = bytearray(text)
39344 eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2441 store.fulltextcache[self._node] = arraytext
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	2442 self._data = treemanifest(
6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	2443 self._manifestlog.nodeconstants, dir=self._dir, text=text
6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	2444 )
29930 be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	2445
be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	2446 return self._data
29911 4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	2447
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	2448 def node(self) -> bytes:
29911 4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	2449 return self._node
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	2450
52097 569e074894fa manifest: drop the CamelCase name for `manifest.memtreemanifestctx` Matt Harbison <matt_harbison@yahoo.com> parents: 52096 diff changeset	2451 def copy(self) -> 'memtreemanifestctx':
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	2452 memmf = memtreemanifestctx(self._manifestlog, dir=self._dir)
30353 952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	2453 memmf._treemanifest = self.read().copy()
952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	2454 return memmf
952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	2455
30570 7fbc8a742b4d manifest: expose the parents() method Mateusz Kwapich <mitrandir@fb.com> parents: 30452 diff changeset	2456 @propertycache
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	2457 def parents(self) -> Tuple[bytes, bytes]:
39344 eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2458 return self._storage().parents(self._node)
30570 7fbc8a742b4d manifest: expose the parents() method Mateusz Kwapich <mitrandir@fb.com> parents: 30452 diff changeset	2459
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	2460 def readdelta(self, shallow: bool = False) -> AnyManifestDict:
51827 ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2461 """see `imanifestrevisionstored` documentation"""
51840 9af1acc1ffab manifest: deprecated readdelta and readfast Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51837 diff changeset	2462 util.nouideprecwarn(
9af1acc1ffab manifest: deprecated readdelta and readfast Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51837 diff changeset	2463 b'"readdelta" is deprecated use "read_any_fast_delta" or "read_delta_new_entries"',
9af1acc1ffab manifest: deprecated readdelta and readfast Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51837 diff changeset	2464 b"6.9",
9af1acc1ffab manifest: deprecated readdelta and readfast Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51837 diff changeset	2465 stacklevel=2,
9af1acc1ffab manifest: deprecated readdelta and readfast Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51837 diff changeset	2466 )
39344 eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2467 store = self._storage()
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	2468 if shallow:
39344 eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2469 r = store.rev(self._node)
eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2470 d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r))
47083 12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	2471 return manifestdict(store.nodeconstants.nodelen, d)
30307 78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	2472 else:
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	2473 # Need to perform a slow delta
39344 eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2474 r0 = store.deltaparent(store.rev(self._node))
eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2475 m0 = self._manifestlog.get(self._dir, store.node(r0)).read()
30307 78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	2476 m1 = self.read()
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	2477 md = treemanifest(self._manifestlog.nodeconstants, dir=self._dir)
49017 3d35e7483602 manifest: remove pycompat.iteritems() Gregory Szorc <gregory.szorc@gmail.com> parents: 49004 diff changeset	2478 for f, ((n0, fl0), (n1, fl1)) in m0.diff(m1).items():
30307 78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	2479 if n1:
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	2480 md[f] = n1
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	2481 if fl1:
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	2482 md.setflag(f, fl1)
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	2483 return md
29942 a059b17352ef manifest: add manifestctx.readdelta() Durham Goode <durham@fb.com> parents: 29930 diff changeset	2484
51827 ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2485 def read_any_fast_delta(
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2486 self,
51828 e1fd715df257 manifest: allow skipping valid_bases argument to `read_any_fast_delta` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51827 diff changeset	2487 valid_bases: Optional[Collection[int]] = None,
51827 ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2488 *,
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2489 shallow: bool = False,
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2490 ) -> Tuple[Optional[int], AnyManifestDict]:
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2491 """see `imanifestrevisionstored` documentation"""
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2492 store = self._storage()
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2493 r = store.rev(self._node)
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2494 deltaparent = store.deltaparent(r)
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2495
51828 e1fd715df257 manifest: allow skipping valid_bases argument to `read_any_fast_delta` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51827 diff changeset	2496 if valid_bases is None:
e1fd715df257 manifest: allow skipping valid_bases argument to `read_any_fast_delta` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51827 diff changeset	2497 # make sure the next check is True
e1fd715df257 manifest: allow skipping valid_bases argument to `read_any_fast_delta` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51827 diff changeset	2498 valid_bases = (deltaparent,)
51827 ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2499 can_use_delta = deltaparent != nullrev and deltaparent in valid_bases
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2500
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2501 if shallow:
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2502 if can_use_delta:
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2503 return (deltaparent, self._read_storage_delta_shallow())
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2504 else:
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2505 d = store.revision(self._node)
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2506 return (None, manifestdict(store.nodeconstants.nodelen, d))
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2507 else:
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2508 # note: This use "slow_delta" here is cargo culted from the previous
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2509 # implementation. I am not sure it make sense since the goal here is to
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2510 # be fast, so why are we computing a delta? On the other hand, tree
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2511 # manifest delta as fairly "cheap" and allow for skipping whole part of
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2512 # the tree that a full read would access. So it might be a good idea.
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2513 #
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2514 # If we realize we don't need delta here, we should simply use:
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2515 #
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2516 # return (None, self.read())
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2517 if can_use_delta:
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2518 return (None, self._read_storage_slow_delta(base=deltaparent))
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2519 else:
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2520 parents = [
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2521 p
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2522 for p in store.parentrevs(r)
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2523 if p is not nullrev and p in valid_bases
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2524 ]
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2525 if parents:
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2526 best_base = max(parents)
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2527 else:
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2528 best_base = max(valid_bases)
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2529 return (None, self._read_storage_slow_delta(base=best_base))
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2530
52091 35400ce47b64 manifest: drop the CamelCase name for `manifest.manifestdict` Matt Harbison <matt_harbison@yahoo.com> parents: 51909 diff changeset	2531 def _read_storage_delta_shallow(self) -> manifestdict:
51827 ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2532 store = self._storage()
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2533 r = store.rev(self._node)
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2534 d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r))
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2535 return manifestdict(store.nodeconstants.nodelen, d)
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2536
52092 c392d57e8a06 manifest: drop the CamelCase name for `manifest.treemanifest` Matt Harbison <matt_harbison@yahoo.com> parents: 52091 diff changeset	2537 def _read_storage_slow_delta(self, base) -> 'treemanifest':
51827 ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2538 store = self._storage()
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2539 if base is None:
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2540 base = store.deltaparent(store.rev(self._node))
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2541 m0 = self._manifestlog.get(self._dir, store.node(base)).read()
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2542 m1 = self.read()
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2543 md = treemanifest(self._manifestlog.nodeconstants, dir=self._dir)
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2544 for f, ((n0, fl0), (n1, fl1)) in m0.diff(m1).items():
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2545 if n1:
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2546 md[f] = n1
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2547 if fl1:
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2548 md.setflag(f, fl1)
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2549 return md
ca4208713875 manifest: introduce a `read_any_fast_delta` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51826 diff changeset	2550
51833 a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2551 def read_delta_parents(
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2552 self,
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2553 *,
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2554 shallow: bool = False,
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2555 exact: bool = True,
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2556 ) -> AnyManifestDict:
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2557 """see `interface.imanifestrevisionbase` documentations"""
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2558 store = self._storage()
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2559 r = store.rev(self._node)
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2560 parents = [p for p in store.parentrevs(r) if p is not nullrev]
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2561 if not exact:
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2562 return self.read_any_fast_delta(parents, shallow=shallow)[1]
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2563 elif len(parents) == 0:
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2564 if shallow:
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2565 d = store.revision(self._node)
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2566 return manifestdict(store.nodeconstants.nodelen, d)
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2567 else:
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2568 return self.read()
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2569 elif len(parents) == 1:
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2570 p = parents[0]
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2571 if shallow:
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2572 d = mdiff.patchtext(store.revdiff(p, r))
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2573 return manifestdict(store.nodeconstants.nodelen, d)
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2574 else:
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2575 return self._read_storage_slow_delta(base=p)
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2576 else:
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2577 p1, p2 = parents
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2578 if shallow:
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2579 d1 = mdiff.patchtext(store.revdiff(p1, r))
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2580 d2 = mdiff.patchtext(store.revdiff(p2, r))
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2581 d1 = manifestdict(store.nodeconstants.nodelen, d1)
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2582 d2 = manifestdict(store.nodeconstants.nodelen, d2)
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2583 md = manifestdict(store.nodeconstants.nodelen)
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2584 for f, new_node, new_flag in d1.iterentries():
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2585 if f not in d2:
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2586 continue
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2587 if new_node is not None:
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2588 md.set(f, new_node, new_flag)
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2589 return md
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2590 else:
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2591 m1 = self._manifestlog.get(self._dir, store.node(p1)).read()
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2592 m2 = self._manifestlog.get(self._dir, store.node(p2)).read()
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2593 mc = self.read()
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2594 d1 = m1.diff(mc)
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2595 d2 = m2.diff(mc)
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2596 md = treemanifest(
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2597 self._manifestlog.nodeconstants,
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2598 dir=self._dir,
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2599 )
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2600 for f, new_node, new_flag in d1.iterentries():
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2601 if f not in d2:
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2602 continue
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2603 if new_node is not None:
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2604 md.set(f, new_node, new_flag)
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2605 return md
a891347058e7 manifest: introduce a `read_delta_parents` method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51828 diff changeset	2606
51837 bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2607 def read_delta_new_entries(
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2608 self, *, shallow: bool = False
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2609 ) -> AnyManifestDict:
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2610 """see `interface.imanifestrevisionbase` documentations"""
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2611 # If we are using narrow, returning a delta against an arbitrary
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2612 # changeset might return file outside the narrowspec. This can create
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2613 # issue when running validation server side with strict security as
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2614 # push from low priviledge usage might be seen as adding new revision
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2615 # for files they cannot touch. So we are strict if narrow is involved.
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2616 if self._manifestlog.narrowed:
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2617 return self.read_delta_parents(shallow=shallow, exact=True)
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2618 # delegate to existing another existing method for simplicity
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2619 store = self._storage()
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2620 r = store.rev(self._node)
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2621 bases = (store.deltaparent(r),)
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2622 return self.read_any_fast_delta(bases, shallow=shallow)[1]
bcb825bf0c5e manifest: add a read_delta_new_entries method Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51833 diff changeset	2623
52503 048c11993d6a typing: (mostly) align the signatures of `imanifestrevisionstored` overrides Matt Harbison <matt_harbison@yahoo.com> parents: 52250 diff changeset	2624 def readfast(self, shallow: bool = False) -> AnyManifestDict:
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	2625 """Calls either readdelta or read, based on which would be less work.
30308 bce79dfcf5e4 manifest: get rid of manifest.readshallowfast Durham Goode <durham@fb.com> parents: 30307 diff changeset	2626 readdelta is called if the delta is against the p1, and therefore can be
bce79dfcf5e4 manifest: get rid of manifest.readshallowfast Durham Goode <durham@fb.com> parents: 30307 diff changeset	2627 read quickly.
bce79dfcf5e4 manifest: get rid of manifest.readshallowfast Durham Goode <durham@fb.com> parents: 30307 diff changeset	2628
bce79dfcf5e4 manifest: get rid of manifest.readshallowfast Durham Goode <durham@fb.com> parents: 30307 diff changeset	2629 If `shallow` is True, it only returns the entries from this manifest,
bce79dfcf5e4 manifest: get rid of manifest.readshallowfast Durham Goode <durham@fb.com> parents: 30307 diff changeset	2630 and not any submanifests.
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45811 diff changeset	2631 """
51840 9af1acc1ffab manifest: deprecated readdelta and readfast Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51837 diff changeset	2632 util.nouideprecwarn(
9af1acc1ffab manifest: deprecated readdelta and readfast Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51837 diff changeset	2633 b'"readdelta" is deprecated use "read_any_fast_delta" or "read_delta_parents"',
9af1acc1ffab manifest: deprecated readdelta and readfast Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51837 diff changeset	2634 b"6.9",
9af1acc1ffab manifest: deprecated readdelta and readfast Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51837 diff changeset	2635 stacklevel=2,
9af1acc1ffab manifest: deprecated readdelta and readfast Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51837 diff changeset	2636 )
39344 eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2637 store = self._storage()
eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2638 r = store.rev(self._node)
eb9b8679c852 manifest: change terminology for storage in context classes Gregory Szorc <gregory.szorc@gmail.com> parents: 39343 diff changeset	2639 deltaparent = store.deltaparent(r)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2640 if deltaparent != nullrev and deltaparent in store.parentrevs(r):
30307 78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	2641 return self.readdelta(shallow=shallow)
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	2642
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	2643 if shallow:
47083 12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	2644 return manifestdict(
12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	2645 store.nodeconstants.nodelen, store.revision(self._node)
12450fbea288 manifests: push down expected node length into the parser Joerg Sonnenberger <joerg@bec.de> parents: 47055 diff changeset	2646 )
30307 78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	2647 else:
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	2648 return self.read()
29943 80be4436e4cc manifest: adds manifestctx.readfast Durham Goode <durham@fb.com> parents: 29942 diff changeset	2649
51826 79e0ee356f32 manifest: add many type annotations to the manifest module Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51825 diff changeset	2650 def find(self, key: bytes) -> Tuple[bytes, bytes]:
30350 608ba935e041 manifest: remove manifest.find Durham Goode <durham@fb.com> parents: 30348 diff changeset	2651 return self.read().find(key)
37372 1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2652
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2653
37372 1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2654 class excludeddir(treemanifest):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2655 """Stand-in for a directory that is excluded from the repository.
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2656
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2657 With narrowing active on a repository that uses treemanifests,
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2658 some of the directory revlogs will be excluded from the resulting
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2659 clone. This is a huge storage win for clients, but means we need
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2660 some sort of pseudo-manifest to surface to internals so we can
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2661 detect a merge conflict outside the narrowspec. That's what this
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2662 class is: it stands in for a directory whose node is known, but
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2663 whose contents are unknown.
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2664 """
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2665
51868 0338fb200a30 typing: lock in new pytype gains from making revlog related classes typeable Matt Harbison <matt_harbison@yahoo.com> parents: 51865 diff changeset	2666 _files: Dict[bytes, bytes]
0338fb200a30 typing: lock in new pytype gains from making revlog related classes typeable Matt Harbison <matt_harbison@yahoo.com> parents: 51865 diff changeset	2667 _flags: Dict[bytes, bytes]
0338fb200a30 typing: lock in new pytype gains from making revlog related classes typeable Matt Harbison <matt_harbison@yahoo.com> parents: 51865 diff changeset	2668
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	2669 def __init__(self, nodeconstants, dir, node):
6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	2670 super(excludeddir, self).__init__(nodeconstants, dir)
37372 1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2671 self._node = node
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2672 # Add an empty file, which will be included by iterators and such,
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2673 # appearing as the directory itself (i.e. something like "dir/")
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	2674 self._files[b''] = node
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	2675 self._flags[b''] = b't'
37372 1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2676
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2677 # Manifests outside the narrowspec should never be modified, so avoid
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2678 # copying. This makes a noticeable difference when there are very many
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2679 # directories outside the narrowspec. Also, it makes sense for the copy to
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2680 # be of the same type as the original, which would not happen with the
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2681 # super type's copy().
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2682 def copy(self):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2683 return self
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2684
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2685
37372 1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2686 class excludeddirmanifestctx(treemanifestctx):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2687 """context wrapper for excludeddir - see that docstring for rationale"""
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2688
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	2689 def __init__(self, nodeconstants, dir, node):
6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	2690 self.nodeconstants = nodeconstants
37372 1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2691 self._dir = dir
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2692 self._node = node
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2693
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2694 def read(self):
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	2695 return excludeddir(self.nodeconstants, self._dir, self._node)
37372 1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2696
52503 048c11993d6a typing: (mostly) align the signatures of `imanifestrevisionstored` overrides Matt Harbison <matt_harbison@yahoo.com> parents: 52250 diff changeset	2697 def readfast(self, shallow: bool = False):
46247 a3ccbac659d8 narrow: overwrite readfast in excludeddirmanifestctx Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46096 diff changeset	2698 # special version of readfast since we don't have underlying storage
a3ccbac659d8 narrow: overwrite readfast in excludeddirmanifestctx Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46096 diff changeset	2699 return self.read()
a3ccbac659d8 narrow: overwrite readfast in excludeddirmanifestctx Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46096 diff changeset	2700
37372 1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2701 def write(self, *args):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2702 raise error.ProgrammingError(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	2703 b'attempt to write manifest from excluded dir %s' % self._dir
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2704 )
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2705
37372 1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2706
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2707 class excludedmanifestrevlog(manifestrevlog):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2708 """Stand-in for excluded treemanifest revlogs.
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2709
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2710 When narrowing is active on a treemanifest repository, we'll have
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2711 references to directories we can't see due to the revlog being
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2712 skipped. This class exists to conform to the manifestrevlog
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2713 interface for those directories and proactively prevent writes to
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2714 outside the narrowspec.
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2715 """
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2716
46793 6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	2717 def __init__(self, nodeconstants, dir):
6266d19556ad node: introduce nodeconstants class Joerg Sonnenberger <joerg@bec.de> parents: 46728 diff changeset	2718 self.nodeconstants = nodeconstants
37372 1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2719 self._dir = dir
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2720
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2721 def __len__(self):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2722 raise error.ProgrammingError(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	2723 b'attempt to get length of excluded dir %s' % self._dir
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2724 )
37372 1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2725
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2726 def rev(self, node):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2727 raise error.ProgrammingError(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	2728 b'attempt to get rev from excluded dir %s' % self._dir
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2729 )
37372 1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2730
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2731 def linkrev(self, node):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2732 raise error.ProgrammingError(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	2733 b'attempt to get linkrev from excluded dir %s' % self._dir
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2734 )
37372 1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2735
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2736 def node(self, rev):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2737 raise error.ProgrammingError(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	2738 b'attempt to get node from excluded dir %s' % self._dir
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42824 diff changeset	2739 )
37372 1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2740
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2741 def add(self, args, *kwargs):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2742 # We should never write entries in dirlogs outside the narrow clone.
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2743 # However, the method still gets called from writesubtree() in
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2744 # _addtree(), so we need to handle it. We should possibly make that
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2745 # avoid calling add() with a clean manifest (_dirty is always False
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2746 # in excludeddir instances).
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	2747 pass

Mercurial > public > mercurial-scm > hg-stable

annotate mercurial/manifest.py @ 52665:24ee91ba9aa8