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