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

annotate mercurial/manifest.py @ 53042:cdd7bf612c7b stable tip

bundle-spec: properly format boolean parameter (issue6960) This was breaking automatic clone bundle generation. This changeset fixes it and add a test to catch it in the future.

author	Pierre-Yves David <pierre-yves.david@octobus.net>
date	Tue, 11 Mar 2025 02:29:42 +0100
parents	de36c56224e0
children

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

Mercurial > public > mercurial-scm > hg

annotate mercurial/manifest.py @ 53042:cdd7bf612c7b stable tip