Mercurial > hg
annotate mercurial/manifest.py @ 45796:e9555305c5c6
templates: include all non-branch namespaces in default one-line summary
I left out branches and custom namespaces on purpose from D9252
because I figured that people like us (Google) who have custom
namespaces can also have custom configs. However, I just realized that
this makes everyone with the topic extension lose the topic they've
had in rebase output for a long time (ever since someone was nice
enough to add it in D741). Sorry about the churn.
The more generic template couldn't easily keep the "log.bookmark"
label in the template because the namespace is called "bookmarks"
(plural). That means that we can't be compatible with users' existing
configs for "log.bookmark", so I decided to change the labels to be in
a brand-new "oneline-summary" namespace.
Differential Revision: https://phab.mercurial-scm.org/D9262
author | Martin von Zweigbergk <martinvonz@google.com> |
---|---|
date | Thu, 29 Oct 2020 09:03:08 -0700 |
parents | a5206e71c536 |
children | 89a2afe31e82 |
rev | line source |
---|---|
1089 | 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 # |
4635
63b9d2deed48
Updated copyright notices and add "and others" to "hg version"
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4633
diff
changeset
|
3 # Copyright 2005-2007 Matt Mackall <mpm@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 | 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 from __future__ import absolute_import |
2df7f5c09c34
manifest: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27466
diff
changeset
|
9 |
2df7f5c09c34
manifest: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27466
diff
changeset
|
10 import heapq |
32536
aa333c1982ab
manifest: use itertools.chain() instead of + for Python 3 compat
Augie Fackler <raf@durin42.com>
parents:
32535
diff
changeset
|
11 import itertools |
27502
2df7f5c09c34
manifest: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27466
diff
changeset
|
12 import struct |
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 |
2df7f5c09c34
manifest: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27466
diff
changeset
|
15 from .i18n import _ |
31530
160e7ad941e9
manifest: use node.hex instead of .encode('hex')
Augie Fackler <augie@google.com>
parents:
31476
diff
changeset
|
16 from .node import ( |
160e7ad941e9
manifest: use node.hex instead of .encode('hex')
Augie Fackler <augie@google.com>
parents:
31476
diff
changeset
|
17 bin, |
160e7ad941e9
manifest: use node.hex instead of .encode('hex')
Augie Fackler <augie@google.com>
parents:
31476
diff
changeset
|
18 hex, |
39316
53363a8eff57
manifest: don't go through revlog to access node symbols
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39315
diff
changeset
|
19 nullid, |
53363a8eff57
manifest: don't go through revlog to access node symbols
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39315
diff
changeset
|
20 nullrev, |
31530
160e7ad941e9
manifest: use node.hex instead of .encode('hex')
Augie Fackler <augie@google.com>
parents:
31476
diff
changeset
|
21 ) |
43089
c59eb1560c44
py3: manually import getattr where it is needed
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43077
diff
changeset
|
22 from .pycompat import getattr |
27502
2df7f5c09c34
manifest: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27466
diff
changeset
|
23 from . import ( |
44247
c443b9ba6f63
py3: __repr__ needs to return str, not bytes
Kyle Lippincott <spectral@google.com>
parents:
43778
diff
changeset
|
24 encoding, |
27502
2df7f5c09c34
manifest: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27466
diff
changeset
|
25 error, |
44286
bbecb6d80aa7
manifest: rewrite filesnotin to not make superfluous manifest copies
Augie Fackler <augie@google.com>
parents:
44285
diff
changeset
|
26 match as matchmod, |
27502
2df7f5c09c34
manifest: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27466
diff
changeset
|
27 mdiff, |
43523
c21aca51b392
utils: move the `dirs` definition in pathutil (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43506
diff
changeset
|
28 pathutil, |
32372
df448de7cf3b
parsers: switch to policy importer
Yuya Nishihara <yuya@tcha.org>
parents:
32252
diff
changeset
|
29 policy, |
38331
cf59de802883
py3: remove b'' from error message of disallowed filename
Yuya Nishihara <yuya@tcha.org>
parents:
37374
diff
changeset
|
30 pycompat, |
27502
2df7f5c09c34
manifest: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27466
diff
changeset
|
31 revlog, |
2df7f5c09c34
manifest: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27466
diff
changeset
|
32 util, |
2df7f5c09c34
manifest: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27466
diff
changeset
|
33 ) |
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
|
34 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
|
35 repository, |
42814
2c4f656c8e9f
interfaceutil: move to interfaces/
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
42813
diff
changeset
|
36 util as interfaceutil, |
38530
c82ea938efbb
repository: define manifest interfaces
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38510
diff
changeset
|
37 ) |
79 | 38 |
43506
9f70512ae2cf
cleanup: remove pointless r-prefixes on single-quoted strings
Augie Fackler <augie@google.com>
parents:
43346
diff
changeset
|
39 parsers = policy.importmod('parsers') |
24322
f263814c72ac
manifest: add dirs() to manifestdict
Drew Gottlieb <drgott@google.com>
parents:
24298
diff
changeset
|
40 propertycache = util.propertycache |
24225
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
41 |
42376
89c0c8edc9d4
tests: demonstrate broken manifest generation with the pure module
Matt Harbison <matt_harbison@yahoo.com>
parents:
41965
diff
changeset
|
42 # 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
|
43 FASTDELTA_TEXTDIFF_THRESHOLD = 1000 |
89c0c8edc9d4
tests: demonstrate broken manifest generation with the pure module
Matt Harbison <matt_harbison@yahoo.com>
parents:
41965
diff
changeset
|
44 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
45 |
36373
0147a4730420
cleanup: say goodbye to manifestv2 format
Augie Fackler <augie@google.com>
parents:
36301
diff
changeset
|
46 def _parse(data): |
24524
63b6031384fc
manifest: extract method for parsing manifest
Martin von Zweigbergk <martinvonz@google.com>
parents:
24502
diff
changeset
|
47 # 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
|
48 # 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
|
49 # 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
|
50 # 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
|
51 # the pure version. |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
52 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
|
53 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
|
54 prev = None |
63b6031384fc
manifest: extract method for parsing manifest
Martin von Zweigbergk <martinvonz@google.com>
parents:
24502
diff
changeset
|
55 for l in data.splitlines(): |
63b6031384fc
manifest: extract method for parsing manifest
Martin von Zweigbergk <martinvonz@google.com>
parents:
24502
diff
changeset
|
56 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
|
57 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
|
58 prev = l |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
59 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
|
60 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
|
61 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
|
62 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
|
63 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
|
64 nl -= 1 |
24524
63b6031384fc
manifest: extract method for parsing manifest
Martin von Zweigbergk <martinvonz@google.com>
parents:
24502
diff
changeset
|
65 else: |
45119
19748c73c208
manifest: use the same logic for handling flags in _parse as elsewhere
Joerg Sonnenberger <joerg@bec.de>
parents:
45118
diff
changeset
|
66 flags = b'' |
19748c73c208
manifest: use the same logic for handling flags in _parse as elsewhere
Joerg Sonnenberger <joerg@bec.de>
parents:
45118
diff
changeset
|
67 if nl not in (40, 64): |
19748c73c208
manifest: use the same logic for handling flags in _parse as elsewhere
Joerg Sonnenberger <joerg@bec.de>
parents:
45118
diff
changeset
|
68 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
|
69 |
19748c73c208
manifest: use the same logic for handling flags in _parse as elsewhere
Joerg Sonnenberger <joerg@bec.de>
parents:
45118
diff
changeset
|
70 yield f, bin(n), flags |
24524
63b6031384fc
manifest: extract method for parsing manifest
Martin von Zweigbergk <martinvonz@google.com>
parents:
24502
diff
changeset
|
71 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
72 |
36373
0147a4730420
cleanup: say goodbye to manifestv2 format
Augie Fackler <augie@google.com>
parents:
36301
diff
changeset
|
73 def _text(it): |
24525
e118f74d246f
manifest: extract method for creating manifest text
Martin von Zweigbergk <martinvonz@google.com>
parents:
24524
diff
changeset
|
74 files = [] |
e118f74d246f
manifest: extract method for creating manifest text
Martin von Zweigbergk <martinvonz@google.com>
parents:
24524
diff
changeset
|
75 lines = [] |
e118f74d246f
manifest: extract method for creating manifest text
Martin von Zweigbergk <martinvonz@google.com>
parents:
24524
diff
changeset
|
76 for f, n, fl in it: |
e118f74d246f
manifest: extract method for creating manifest text
Martin von Zweigbergk <martinvonz@google.com>
parents:
24524
diff
changeset
|
77 files.append(f) |
e118f74d246f
manifest: extract method for creating manifest text
Martin von Zweigbergk <martinvonz@google.com>
parents:
24524
diff
changeset
|
78 # 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
|
79 # 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
|
80 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
|
81 |
e118f74d246f
manifest: extract method for creating manifest text
Martin von Zweigbergk <martinvonz@google.com>
parents:
24524
diff
changeset
|
82 _checkforbidden(files) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
83 return b''.join(lines) |
24525
e118f74d246f
manifest: extract method for creating manifest text
Martin von Zweigbergk <martinvonz@google.com>
parents:
24524
diff
changeset
|
84 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
85 |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
86 class lazymanifestiter(object): |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
87 def __init__(self, lm): |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
88 self.pos = 0 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
89 self.lm = lm |
24225
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
90 |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
91 def __iter__(self): |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
92 return self |
24223
b4df0d0c49e7
manifest: move parsing functions up in file
Augie Fackler <augie@google.com>
parents:
24215
diff
changeset
|
93 |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
94 def next(self): |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
95 try: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
96 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
|
97 except IndexError: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
98 raise StopIteration |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
99 if pos == -1: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
100 self.pos += 1 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
101 return data[0] |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
102 self.pos += 1 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
103 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
|
104 return data[pos:zeropos] |
24224
d71837d06597
manifest: do parsing inside manifestdict contstructor
Augie Fackler <augie@google.com>
parents:
24223
diff
changeset
|
105 |
31364
91874c247d61
manifest: add __next__ methods for Python 3
Augie Fackler <augie@google.com>
parents:
31352
diff
changeset
|
106 __next__ = next |
91874c247d61
manifest: add __next__ methods for Python 3
Augie Fackler <augie@google.com>
parents:
31352
diff
changeset
|
107 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
108 |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
109 class lazymanifestiterentries(object): |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
110 def __init__(self, lm): |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
111 self.lm = lm |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
112 self.pos = 0 |
24225
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
113 |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
114 def __iter__(self): |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
115 return self |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
116 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
117 def next(self): |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
118 try: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
119 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
|
120 except IndexError: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
121 raise StopIteration |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
122 if pos == -1: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
123 self.pos += 1 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
124 return data |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
125 zeropos = data.find(b'\x00', pos) |
45118
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
126 nlpos = data.find(b'\n', pos) |
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
127 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
|
128 raise error.StorageError(b'Invalid manifest line') |
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
129 flags = data[nlpos - 1 : nlpos] |
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
130 if flags in _manifestflags: |
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
131 hlen = nlpos - zeropos - 2 |
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
132 else: |
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
133 hlen = nlpos - zeropos - 1 |
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
134 flags = b'' |
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
135 if hlen not in (40, 64): |
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
136 raise error.StorageError(b'Invalid manifest line') |
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
137 hashval = unhexlify( |
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
138 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
|
139 ) |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
140 self.pos += 1 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
141 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
|
142 |
31364
91874c247d61
manifest: add __next__ methods for Python 3
Augie Fackler <augie@google.com>
parents:
31352
diff
changeset
|
143 __next__ = next |
91874c247d61
manifest: add __next__ methods for Python 3
Augie Fackler <augie@google.com>
parents:
31352
diff
changeset
|
144 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
145 |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
146 def unhexlify(data, extra, pos, length): |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
147 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
|
148 if extra: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
149 s += chr(extra & 0xFF) |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
150 return s |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
151 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
152 |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
153 def _cmp(a, b): |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
154 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
|
155 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
156 |
45118
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
157 _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
|
158 |
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 class _lazymanifest(object): |
42378
c3484ddbdb96
manifest: add some documentation to _lazymanifest python code
Matt Harbison <matt_harbison@yahoo.com>
parents:
42377
diff
changeset
|
161 """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
|
162 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
|
163 string. |
c3484ddbdb96
manifest: add some documentation to _lazymanifest python code
Matt Harbison <matt_harbison@yahoo.com>
parents:
42377
diff
changeset
|
164 |
c3484ddbdb96
manifest: add some documentation to _lazymanifest python code
Matt Harbison <matt_harbison@yahoo.com>
parents:
42377
diff
changeset
|
165 ``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
|
166 |
c3484ddbdb96
manifest: add some documentation to _lazymanifest python code
Matt Harbison <matt_harbison@yahoo.com>
parents:
42377
diff
changeset
|
167 ``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
|
168 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
|
169 ``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
|
170 ``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
|
171 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
|
172 sorted by filename. |
c3484ddbdb96
manifest: add some documentation to _lazymanifest python code
Matt Harbison <matt_harbison@yahoo.com>
parents:
42377
diff
changeset
|
173 |
c3484ddbdb96
manifest: add some documentation to _lazymanifest python code
Matt Harbison <matt_harbison@yahoo.com>
parents:
42377
diff
changeset
|
174 ``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
|
175 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
|
176 """ |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
177 |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
178 def __init__( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
179 self, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
180 data, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
181 positions=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
182 extrainfo=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
183 extradata=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
184 hasremovals=False, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
185 ): |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
186 if positions is None: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
187 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
|
188 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
|
189 self.data = data |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
190 self.extradata = [] |
42377
0546ead39a7e
manifest: avoid corruption by dropping removed files with pure (issue5801)
Matt Harbison <matt_harbison@yahoo.com>
parents:
42376
diff
changeset
|
191 self.hasremovals = False |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
192 else: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
193 self.positions = positions[:] |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
194 self.extrainfo = extrainfo[:] |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
195 self.extradata = extradata[:] |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
196 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
|
197 self.hasremovals = hasremovals |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
198 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
199 def findlines(self, data): |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
200 if not data: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
201 return [] |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
202 pos = data.find(b"\n") |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
203 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
|
204 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
|
205 positions = [0] |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
206 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
|
207 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
|
208 positions.append(pos + 1) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
209 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
|
210 if nexts < prev: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
211 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
|
212 prev = nexts |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
213 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
|
214 return positions |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
215 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
216 def _get(self, index): |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
217 # 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
|
218 # 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
|
219 # 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
|
220 pos = self.positions[index] |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
221 if pos >= 0: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
222 return self.data, pos |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
223 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
|
224 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
225 def _getkey(self, pos): |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
226 if pos >= 0: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
227 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
|
228 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
|
229 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
230 def bsearch(self, key): |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
231 first = 0 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
232 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
|
233 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
234 while first <= last: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
235 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
|
236 nextpos = self.positions[midpoint] |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
237 candidate = self._getkey(nextpos) |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
238 r = _cmp(key, candidate) |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
239 if r == 0: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
240 return midpoint |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
241 else: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
242 if r < 0: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
243 last = midpoint - 1 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
244 else: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
245 first = midpoint + 1 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
246 return -1 |
24225
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
247 |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
248 def bsearch2(self, key): |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
249 # 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
|
250 # done for performance reasons |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
251 first = 0 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
252 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
|
253 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
254 while first <= last: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
255 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
|
256 nextpos = self.positions[midpoint] |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
257 candidate = self._getkey(nextpos) |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
258 r = _cmp(key, candidate) |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
259 if r == 0: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
260 return (midpoint, True) |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
261 else: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
262 if r < 0: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
263 last = midpoint - 1 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
264 else: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
265 first = midpoint + 1 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
266 return (first, False) |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
267 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
268 def __contains__(self, key): |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
269 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
|
270 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
271 def __getitem__(self, key): |
31367
ef50b491c17d
manifest: ensure paths are bytes (not str) in pure parser
Augie Fackler <augie@google.com>
parents:
31366
diff
changeset
|
272 if not isinstance(key, bytes): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
273 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
|
274 needle = self.bsearch(key) |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
275 if needle == -1: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
276 raise KeyError |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
277 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
|
278 if pos == -1: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
279 return (data[1], data[2]) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
280 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
|
281 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
|
282 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
|
283 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
|
284 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
|
285 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
|
286 hlen = nlpos - zeropos - 1 |
45118
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
287 flags = data[nlpos - 1 : nlpos] |
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
288 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
|
289 hlen -= 1 |
45118
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
290 else: |
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
291 flags = b'' |
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
292 if hlen not in (40, 64): |
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
293 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
|
294 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
|
295 return (hashval, flags) |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
296 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
297 def __delitem__(self, key): |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
298 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
|
299 if not found: |
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 cur = self.positions[needle] |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
302 self.positions = self.positions[:needle] + self.positions[needle + 1 :] |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
303 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
|
304 if cur >= 0: |
42378
c3484ddbdb96
manifest: add some documentation to _lazymanifest python code
Matt Harbison <matt_harbison@yahoo.com>
parents:
42377
diff
changeset
|
305 # 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
|
306 # 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
|
307 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
|
308 self.hasremovals = True |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
309 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
310 def __setitem__(self, key, value): |
31531
326bca5477d0
manifest: refer to bytestrings as bytes, not str
Augie Fackler <augie@google.com>
parents:
31530
diff
changeset
|
311 if not isinstance(key, bytes): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
312 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
|
313 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
|
314 raise TypeError( |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
315 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
|
316 ) |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
317 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
|
318 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
|
319 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
|
320 flags = value[1] |
31531
326bca5477d0
manifest: refer to bytestrings as bytes, not str
Augie Fackler <augie@google.com>
parents:
31530
diff
changeset
|
321 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
|
322 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
|
323 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
|
324 if found: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
325 # put the item |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
326 pos = self.positions[needle] |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
327 if pos < 0: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
328 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
|
329 else: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
330 # just don't bother |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
331 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
|
332 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
|
333 else: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
334 # 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
|
335 self.extradata.append((key, hashval, value[1])) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
336 self.positions = ( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
337 self.positions[:needle] |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
338 + [-len(self.extradata)] |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
339 + self.positions[needle:] |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
340 ) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
341 self.extrainfo = ( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
342 self.extrainfo[:needle] + [0] + self.extrainfo[needle:] |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
343 ) |
24298
49cd847fd69a
lazymanifest: make __iter__ generate filenames, not 3-tuples
Martin von Zweigbergk <martinvonz@google.com>
parents:
24297
diff
changeset
|
344 |
2831 | 345 def copy(self): |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
346 # XXX call _compact like in C? |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
347 return _lazymanifest( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
348 self.data, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
349 self.positions, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
350 self.extrainfo, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
351 self.extradata, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
352 self.hasremovals, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
353 ) |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
354 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
355 def _compact(self): |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
356 # 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
|
357 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
|
358 return |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
359 l = [] |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
360 i = 0 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
361 offset = 0 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
362 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
|
363 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
|
364 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
|
365 cur = self.positions[i] |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
366 last_cut = cur |
42378
c3484ddbdb96
manifest: add some documentation to _lazymanifest python code
Matt Harbison <matt_harbison@yahoo.com>
parents:
42377
diff
changeset
|
367 |
c3484ddbdb96
manifest: add some documentation to _lazymanifest python code
Matt Harbison <matt_harbison@yahoo.com>
parents:
42377
diff
changeset
|
368 # 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
|
369 # 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
|
370 # 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
|
371 while True: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
372 self.positions[i] = offset |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
373 i += 1 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
374 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
|
375 break |
42377
0546ead39a7e
manifest: avoid corruption by dropping removed files with pure (issue5801)
Matt Harbison <matt_harbison@yahoo.com>
parents:
42376
diff
changeset
|
376 |
0546ead39a7e
manifest: avoid corruption by dropping removed files with pure (issue5801)
Matt Harbison <matt_harbison@yahoo.com>
parents:
42376
diff
changeset
|
377 # 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
|
378 # 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
|
379 # 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
|
380 # before the next position. |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
381 if ( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
382 self.hasremovals |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
383 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
|
384 != -1 |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
385 ): |
42377
0546ead39a7e
manifest: avoid corruption by dropping removed files with pure (issue5801)
Matt Harbison <matt_harbison@yahoo.com>
parents:
42376
diff
changeset
|
386 break |
0546ead39a7e
manifest: avoid corruption by dropping removed files with pure (issue5801)
Matt Harbison <matt_harbison@yahoo.com>
parents:
42376
diff
changeset
|
387 |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
388 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
|
389 cur = self.positions[i] |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
390 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
|
391 if end_cut != -1: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
392 end_cut += 1 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
393 offset += end_cut - cur |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
394 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
|
395 else: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
396 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
|
397 cur = self.positions[i] |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
398 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
|
399 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
|
400 self.positions[i] = offset |
44704
0415a566742a
manifest: fix another pure-parsing 20-byte assumption
Augie Fackler <augie@google.com>
parents:
44703
diff
changeset
|
401 # 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
|
402 # bytes (new non-sha1). |
0415a566742a
manifest: fix another pure-parsing 20-byte assumption
Augie Fackler <augie@google.com>
parents:
44703
diff
changeset
|
403 hlen = 20 |
0415a566742a
manifest: fix another pure-parsing 20-byte assumption
Augie Fackler <augie@google.com>
parents:
44703
diff
changeset
|
404 if len(t[1]) > 25: |
0415a566742a
manifest: fix another pure-parsing 20-byte assumption
Augie Fackler <augie@google.com>
parents:
44703
diff
changeset
|
405 hlen = 32 |
0415a566742a
manifest: fix another pure-parsing 20-byte assumption
Augie Fackler <augie@google.com>
parents:
44703
diff
changeset
|
406 if len(t[1]) > hlen: |
0415a566742a
manifest: fix another pure-parsing 20-byte assumption
Augie Fackler <augie@google.com>
parents:
44703
diff
changeset
|
407 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
|
408 offset += len(l[-1]) |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
409 i += 1 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
410 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
|
411 self.hasremovals = False |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
412 self.extradata = [] |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
413 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
414 def _pack(self, d): |
44701
ecbba7b2e444
manifest: remove a 20-byte-hash assumption from pure manifest parsing
Augie Fackler <augie@google.com>
parents:
44664
diff
changeset
|
415 n = d[1] |
45118
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
416 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
|
417 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
|
418 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
419 def text(self): |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
420 self._compact() |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
421 return self.data |
24225
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
422 |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
423 def diff(self, m2, clean=False): |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
424 '''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
|
425 # 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
|
426 diff = {} |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
427 |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
428 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
|
429 if fn not in m2: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
430 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
|
431 else: |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
432 e2 = m2[fn] |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
433 if (e1, flags) != e2: |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
434 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
|
435 elif clean: |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
436 diff[fn] = None |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
437 |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
438 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
|
439 if fn not in self: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
440 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
|
441 |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
442 return diff |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
443 |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
444 def iterentries(self): |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
445 return lazymanifestiterentries(self) |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
446 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
447 def iterkeys(self): |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
448 return lazymanifestiter(self) |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
449 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
450 def __iter__(self): |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
451 return lazymanifestiter(self) |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
452 |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
453 def __len__(self): |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
454 return len(self.positions) |
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
455 |
24225
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
456 def filtercopy(self, filterfn): |
30042
d24e03da24b5
lazymanifest: write a more efficient, pypy friendly version of lazymanifest
Maciej Fijalkowski <fijall@gmail.com>
parents:
29998
diff
changeset
|
457 # XXX should be optimized |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
458 c = _lazymanifest(b'') |
24298
49cd847fd69a
lazymanifest: make __iter__ generate filenames, not 3-tuples
Martin von Zweigbergk <martinvonz@google.com>
parents:
24297
diff
changeset
|
459 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
|
460 if filterfn(f): |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
461 c[f] = n, fl |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
462 return c |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
463 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
464 |
24226
b992769dd1be
manifest: use custom C implementation of lazymanifest
Augie Fackler <augie@google.com>
parents:
24225
diff
changeset
|
465 try: |
b992769dd1be
manifest: use custom C implementation of lazymanifest
Augie Fackler <augie@google.com>
parents:
24225
diff
changeset
|
466 _lazymanifest = parsers.lazymanifest |
b992769dd1be
manifest: use custom C implementation of lazymanifest
Augie Fackler <augie@google.com>
parents:
24225
diff
changeset
|
467 except AttributeError: |
b992769dd1be
manifest: use custom C implementation of lazymanifest
Augie Fackler <augie@google.com>
parents:
24225
diff
changeset
|
468 pass |
b992769dd1be
manifest: use custom C implementation of lazymanifest
Augie Fackler <augie@google.com>
parents:
24225
diff
changeset
|
469 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
470 |
38530
c82ea938efbb
repository: define manifest interfaces
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38510
diff
changeset
|
471 @interfaceutil.implementer(repository.imanifestdict) |
24225
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
472 class manifestdict(object): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
473 def __init__(self, data=b''): |
36373
0147a4730420
cleanup: say goodbye to manifestv2 format
Augie Fackler <augie@google.com>
parents:
36301
diff
changeset
|
474 self._lm = _lazymanifest(data) |
24225
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
475 |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
476 def __getitem__(self, key): |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
477 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
|
478 |
24277
22d560fe1516
manifest: don't let find() look inside manifestdict
Martin von Zweigbergk <martinvonz@google.com>
parents:
24226
diff
changeset
|
479 def find(self, key): |
22d560fe1516
manifest: don't let find() look inside manifestdict
Martin von Zweigbergk <martinvonz@google.com>
parents:
24226
diff
changeset
|
480 return self._lm[key] |
22d560fe1516
manifest: don't let find() look inside manifestdict
Martin von Zweigbergk <martinvonz@google.com>
parents:
24226
diff
changeset
|
481 |
24225
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
482 def __len__(self): |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
483 return len(self._lm) |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
484 |
30331
b19291e5d506
manifest: add __nonzero__ method
Durham Goode <durham@fb.com>
parents:
30295
diff
changeset
|
485 def __nonzero__(self): |
b19291e5d506
manifest: add __nonzero__ method
Durham Goode <durham@fb.com>
parents:
30295
diff
changeset
|
486 # 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
|
487 # makes it easier for extensions to override. |
b19291e5d506
manifest: add __nonzero__ method
Durham Goode <durham@fb.com>
parents:
30295
diff
changeset
|
488 return len(self._lm) != 0 |
b19291e5d506
manifest: add __nonzero__ method
Durham Goode <durham@fb.com>
parents:
30295
diff
changeset
|
489 |
31476
413b44003462
py3: add __bool__ to every class defining __nonzero__
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31367
diff
changeset
|
490 __bool__ = __nonzero__ |
413b44003462
py3: add __bool__ to every class defining __nonzero__
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31367
diff
changeset
|
491 |
24225
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
492 def __setitem__(self, key, node): |
44257
dbbae122f5e4
manifest: remove optional default= argument on flags(path)
Augie Fackler <augie@google.com>
parents:
43778
diff
changeset
|
493 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
|
494 |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
495 def __contains__(self, key): |
34345
05167447f90d
py3: return False early while checking whether None is a key in lazymanifest
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34296
diff
changeset
|
496 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
|
497 return False |
24225
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
498 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
|
499 |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
500 def __delitem__(self, key): |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
501 del self._lm[key] |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
502 |
24295
2b7ab29627fd
lazymanifest: add iterkeys() method
Martin von Zweigbergk <martinvonz@google.com>
parents:
24292
diff
changeset
|
503 def __iter__(self): |
24298
49cd847fd69a
lazymanifest: make __iter__ generate filenames, not 3-tuples
Martin von Zweigbergk <martinvonz@google.com>
parents:
24297
diff
changeset
|
504 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
|
505 |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
506 def iterkeys(self): |
24295
2b7ab29627fd
lazymanifest: add iterkeys() method
Martin von Zweigbergk <martinvonz@google.com>
parents:
24292
diff
changeset
|
507 return self._lm.iterkeys() |
2b7ab29627fd
lazymanifest: add iterkeys() method
Martin von Zweigbergk <martinvonz@google.com>
parents:
24292
diff
changeset
|
508 |
2b7ab29627fd
lazymanifest: add iterkeys() method
Martin von Zweigbergk <martinvonz@google.com>
parents:
24292
diff
changeset
|
509 def keys(self): |
2b7ab29627fd
lazymanifest: add iterkeys() method
Martin von Zweigbergk <martinvonz@google.com>
parents:
24292
diff
changeset
|
510 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
|
511 |
31255
959ebff3505a
manifest: add match argument to diff and filesnotin
Durham Goode <durham@fb.com>
parents:
31153
diff
changeset
|
512 def filesnotin(self, m2, match=None): |
24184
cd66080ef6d4
copies: move code into new manifestdict.filesnotin() method
Martin von Zweigbergk <martinvonz@google.com>
parents:
24147
diff
changeset
|
513 '''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
|
514 if match is not None: |
bbecb6d80aa7
manifest: rewrite filesnotin to not make superfluous manifest copies
Augie Fackler <augie@google.com>
parents:
44285
diff
changeset
|
515 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
|
516 sm2 = set(m2.walk(match)) |
bbecb6d80aa7
manifest: rewrite filesnotin to not make superfluous manifest copies
Augie Fackler <augie@google.com>
parents:
44285
diff
changeset
|
517 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
|
518 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
|
519 |
24322
f263814c72ac
manifest: add dirs() to manifestdict
Drew Gottlieb <drgott@google.com>
parents:
24298
diff
changeset
|
520 @propertycache |
f263814c72ac
manifest: add dirs() to manifestdict
Drew Gottlieb <drgott@google.com>
parents:
24298
diff
changeset
|
521 def _dirs(self): |
43523
c21aca51b392
utils: move the `dirs` definition in pathutil (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43506
diff
changeset
|
522 return pathutil.dirs(self) |
24322
f263814c72ac
manifest: add dirs() to manifestdict
Drew Gottlieb <drgott@google.com>
parents:
24298
diff
changeset
|
523 |
f263814c72ac
manifest: add dirs() to manifestdict
Drew Gottlieb <drgott@google.com>
parents:
24298
diff
changeset
|
524 def dirs(self): |
f263814c72ac
manifest: add dirs() to manifestdict
Drew Gottlieb <drgott@google.com>
parents:
24298
diff
changeset
|
525 return self._dirs |
f263814c72ac
manifest: add dirs() to manifestdict
Drew Gottlieb <drgott@google.com>
parents:
24298
diff
changeset
|
526 |
24324
149cc171e4a0
manifest: add manifestdict.hasdir() method
Drew Gottlieb <drgott@google.com>
parents:
24322
diff
changeset
|
527 def hasdir(self, dir): |
149cc171e4a0
manifest: add manifestdict.hasdir() method
Drew Gottlieb <drgott@google.com>
parents:
24322
diff
changeset
|
528 return dir in self._dirs |
149cc171e4a0
manifest: add manifestdict.hasdir() method
Drew Gottlieb <drgott@google.com>
parents:
24322
diff
changeset
|
529 |
24685
b3d78d82d84c
manifestdict: extract condition for _intersectfiles() and use for walk()
Martin von Zweigbergk <martinvonz@google.com>
parents:
24684
diff
changeset
|
530 def _filesfastpath(self, match): |
b3d78d82d84c
manifestdict: extract condition for _intersectfiles() and use for walk()
Martin von Zweigbergk <martinvonz@google.com>
parents:
24684
diff
changeset
|
531 '''Checks whether we can correctly and quickly iterate over matcher |
b3d78d82d84c
manifestdict: extract condition for _intersectfiles() and use for walk()
Martin von Zweigbergk <martinvonz@google.com>
parents:
24684
diff
changeset
|
532 files instead of over manifest files.''' |
b3d78d82d84c
manifestdict: extract condition for _intersectfiles() and use for walk()
Martin von Zweigbergk <martinvonz@google.com>
parents:
24684
diff
changeset
|
533 files = match.files() |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
534 return len(files) < 100 and ( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
535 match.isexact() |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
536 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
|
537 ) |
24685
b3d78d82d84c
manifestdict: extract condition for _intersectfiles() and use for walk()
Martin von Zweigbergk <martinvonz@google.com>
parents:
24684
diff
changeset
|
538 |
24646
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
539 def walk(self, match): |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
540 '''Generates matching file names. |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
541 |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
542 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
|
543 an entirely new manifest. |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
544 |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
545 It also reports nonexistent files by marking them bad with match.bad(). |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
546 ''' |
24683
4eaea0ed8dc1
manifest.walk: special-case match.always() for speed
Martin von Zweigbergk <martinvonz@google.com>
parents:
24682
diff
changeset
|
547 if match.always(): |
4eaea0ed8dc1
manifest.walk: special-case match.always() for speed
Martin von Zweigbergk <martinvonz@google.com>
parents:
24682
diff
changeset
|
548 for f in iter(self): |
4eaea0ed8dc1
manifest.walk: special-case match.always() for speed
Martin von Zweigbergk <martinvonz@google.com>
parents:
24682
diff
changeset
|
549 yield f |
4eaea0ed8dc1
manifest.walk: special-case match.always() for speed
Martin von Zweigbergk <martinvonz@google.com>
parents:
24682
diff
changeset
|
550 return |
4eaea0ed8dc1
manifest.walk: special-case match.always() for speed
Martin von Zweigbergk <martinvonz@google.com>
parents:
24682
diff
changeset
|
551 |
24646
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
552 fset = set(match.files()) |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
553 |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
554 # 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
|
555 if self._filesfastpath(match): |
24667
19c5b0913960
manifest.walk: join nested if-conditions
Martin von Zweigbergk <martinvonz@google.com>
parents:
24666
diff
changeset
|
556 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
|
557 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
|
558 yield fn |
24682
aef3d1469773
manifest.walk: use return instead of StopIteration in generator
Martin von Zweigbergk <martinvonz@google.com>
parents:
24670
diff
changeset
|
559 return |
24646
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
560 |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
561 for fn in self: |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
562 if fn in fset: |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
563 # specified pattern is the exact name |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
564 fset.remove(fn) |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
565 if match(fn): |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
566 yield fn |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
567 |
42341
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41965
diff
changeset
|
568 # 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
|
569 # follow that here, too |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
570 fset.discard(b'') |
24646
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
571 |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
572 for fn in sorted(fset): |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
573 if not self.hasdir(fn): |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
574 match.bad(fn, None) |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
575 |
44352
0bf3b5e80d30
manifest: move matches method to be outside the interface
Augie Fackler <augie@google.com>
parents:
44286
diff
changeset
|
576 def _matches(self, match): |
23305
0cc283f44655
manifest: add matches() method
Martin von Zweigbergk <martinvonz@google.com>
parents:
22966
diff
changeset
|
577 '''generate a new manifest filtered by the match argument''' |
0cc283f44655
manifest: add matches() method
Martin von Zweigbergk <martinvonz@google.com>
parents:
22966
diff
changeset
|
578 if match.always(): |
0cc283f44655
manifest: add matches() method
Martin von Zweigbergk <martinvonz@google.com>
parents:
22966
diff
changeset
|
579 return self.copy() |
0cc283f44655
manifest: add matches() method
Martin von Zweigbergk <martinvonz@google.com>
parents:
22966
diff
changeset
|
580 |
24685
b3d78d82d84c
manifestdict: extract condition for _intersectfiles() and use for walk()
Martin von Zweigbergk <martinvonz@google.com>
parents:
24684
diff
changeset
|
581 if self._filesfastpath(match): |
24666
3092885b5b32
manifestdict: inline _intersectfiles()
Martin von Zweigbergk <martinvonz@google.com>
parents:
24665
diff
changeset
|
582 m = manifestdict() |
3092885b5b32
manifestdict: inline _intersectfiles()
Martin von Zweigbergk <martinvonz@google.com>
parents:
24665
diff
changeset
|
583 lm = self._lm |
3092885b5b32
manifestdict: inline _intersectfiles()
Martin von Zweigbergk <martinvonz@google.com>
parents:
24665
diff
changeset
|
584 for fn in match.files(): |
3092885b5b32
manifestdict: inline _intersectfiles()
Martin von Zweigbergk <martinvonz@google.com>
parents:
24665
diff
changeset
|
585 if fn in lm: |
3092885b5b32
manifestdict: inline _intersectfiles()
Martin von Zweigbergk <martinvonz@google.com>
parents:
24665
diff
changeset
|
586 m._lm[fn] = lm[fn] |
3092885b5b32
manifestdict: inline _intersectfiles()
Martin von Zweigbergk <martinvonz@google.com>
parents:
24665
diff
changeset
|
587 return m |
23305
0cc283f44655
manifest: add matches() method
Martin von Zweigbergk <martinvonz@google.com>
parents:
22966
diff
changeset
|
588 |
24700
32b268cbff00
manifestdict: drop empty-string argument when creating empty manifest
Martin von Zweigbergk <martinvonz@google.com>
parents:
24685
diff
changeset
|
589 m = manifestdict() |
24664
ea4a7c8909ae
manifestdict.matches: avoid name 'lm' for a not-lazymanifest
Martin von Zweigbergk <martinvonz@google.com>
parents:
24647
diff
changeset
|
590 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
|
591 return m |
23305
0cc283f44655
manifest: add matches() method
Martin von Zweigbergk <martinvonz@google.com>
parents:
22966
diff
changeset
|
592 |
31255
959ebff3505a
manifest: add match argument to diff and filesnotin
Durham Goode <durham@fb.com>
parents:
31153
diff
changeset
|
593 def diff(self, m2, match=None, clean=False): |
23756
829f640b5540
manifest: add optional recording of clean entries to diff
Augie Fackler <augie@google.com>
parents:
23602
diff
changeset
|
594 '''Finds changes between the current manifest and m2. |
829f640b5540
manifest: add optional recording of clean entries to diff
Augie Fackler <augie@google.com>
parents:
23602
diff
changeset
|
595 |
829f640b5540
manifest: add optional recording of clean entries to diff
Augie Fackler <augie@google.com>
parents:
23602
diff
changeset
|
596 Args: |
829f640b5540
manifest: add optional recording of clean entries to diff
Augie Fackler <augie@google.com>
parents:
23602
diff
changeset
|
597 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
|
598 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
|
599 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
|
600 |
829f640b5540
manifest: add optional recording of clean entries to diff
Augie Fackler <augie@google.com>
parents:
23602
diff
changeset
|
601 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
|
602 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
|
603 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
|
604 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
|
605 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
|
606 string. |
829f640b5540
manifest: add optional recording of clean entries to diff
Augie Fackler <augie@google.com>
parents:
23602
diff
changeset
|
607 ''' |
31255
959ebff3505a
manifest: add match argument to diff and filesnotin
Durham Goode <durham@fb.com>
parents:
31153
diff
changeset
|
608 if match: |
44352
0bf3b5e80d30
manifest: move matches method to be outside the interface
Augie Fackler <augie@google.com>
parents:
44286
diff
changeset
|
609 m1 = self._matches(match) |
0bf3b5e80d30
manifest: move matches method to be outside the interface
Augie Fackler <augie@google.com>
parents:
44286
diff
changeset
|
610 m2 = m2._matches(match) |
31255
959ebff3505a
manifest: add match argument to diff and filesnotin
Durham Goode <durham@fb.com>
parents:
31153
diff
changeset
|
611 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
|
612 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
|
613 |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
614 def setflag(self, key, flag): |
45118
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
615 if flag not in _manifestflags: |
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
616 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
|
617 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
|
618 |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
619 def get(self, key, default=None): |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
620 try: |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
621 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
|
622 except KeyError: |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
623 return default |
22965
b697fa74b475
manifest: for diff(), only iterate over files, not flags
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
22964
diff
changeset
|
624 |
44257
dbbae122f5e4
manifest: remove optional default= argument on flags(path)
Augie Fackler <augie@google.com>
parents:
43778
diff
changeset
|
625 def flags(self, key): |
24225
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
626 try: |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
627 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
|
628 except KeyError: |
44257
dbbae122f5e4
manifest: remove optional default= argument on flags(path)
Augie Fackler <augie@google.com>
parents:
43778
diff
changeset
|
629 return b'' |
22965
b697fa74b475
manifest: for diff(), only iterate over files, not flags
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
22964
diff
changeset
|
630 |
24225
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
631 def copy(self): |
24700
32b268cbff00
manifestdict: drop empty-string argument when creating empty manifest
Martin von Zweigbergk <martinvonz@google.com>
parents:
24685
diff
changeset
|
632 c = manifestdict() |
24225
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
633 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
|
634 return c |
3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
Augie Fackler <augie@google.com>
parents:
24224
diff
changeset
|
635 |
32550
b98199a5c3e1
cleanup: rename all iteritems methods to items and add iteritems alias
Augie Fackler <raf@durin42.com>
parents:
32536
diff
changeset
|
636 def items(self): |
24298
49cd847fd69a
lazymanifest: make __iter__ generate filenames, not 3-tuples
Martin von Zweigbergk <martinvonz@google.com>
parents:
24297
diff
changeset
|
637 return (x[:2] for x in self._lm.iterentries()) |
2831 | 638 |
38657
28c9d67d88ab
manifest: just duplicate the definition of items as iteritems
Augie Fackler <augie@google.com>
parents:
38556
diff
changeset
|
639 def iteritems(self): |
28c9d67d88ab
manifest: just duplicate the definition of items as iteritems
Augie Fackler <augie@google.com>
parents:
38556
diff
changeset
|
640 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
|
641 |
28203
7297e9e13a8a
verify: check directory manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
27502
diff
changeset
|
642 def iterentries(self): |
7297e9e13a8a
verify: check directory manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
27502
diff
changeset
|
643 return self._lm.iterentries() |
7297e9e13a8a
verify: check directory manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
27502
diff
changeset
|
644 |
36373
0147a4730420
cleanup: say goodbye to manifestv2 format
Augie Fackler <augie@google.com>
parents:
36301
diff
changeset
|
645 def text(self): |
0147a4730420
cleanup: say goodbye to manifestv2 format
Augie Fackler <augie@google.com>
parents:
36301
diff
changeset
|
646 # most likely uses native version |
0147a4730420
cleanup: say goodbye to manifestv2 format
Augie Fackler <augie@google.com>
parents:
36301
diff
changeset
|
647 return self._lm.text() |
22408
dc97e04c12ad
manifest: move checkforbidden to module-level
Augie Fackler <raf@durin42.com>
parents:
21879
diff
changeset
|
648 |
22931
48c0b101a9de
manifest: add fastdelta method to manifestdict
Augie Fackler <raf@durin42.com>
parents:
22930
diff
changeset
|
649 def fastdelta(self, base, changes): |
31787
6bfea18df609
manifest: update comment to be about bytearray
Martin von Zweigbergk <martinvonz@google.com>
parents:
31650
diff
changeset
|
650 """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
|
651 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
|
652 """ |
48c0b101a9de
manifest: add fastdelta method to manifestdict
Augie Fackler <raf@durin42.com>
parents:
22930
diff
changeset
|
653 delta = [] |
48c0b101a9de
manifest: add fastdelta method to manifestdict
Augie Fackler <raf@durin42.com>
parents:
22930
diff
changeset
|
654 dstart = None |
48c0b101a9de
manifest: add fastdelta method to manifestdict
Augie Fackler <raf@durin42.com>
parents:
22930
diff
changeset
|
655 dend = None |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
656 dline = [b""] |
22931
48c0b101a9de
manifest: add fastdelta method to manifestdict
Augie Fackler <raf@durin42.com>
parents:
22930
diff
changeset
|
657 start = 0 |
48c0b101a9de
manifest: add fastdelta method to manifestdict
Augie Fackler <raf@durin42.com>
parents:
22930
diff
changeset
|
658 # zero copy representation of base as a buffer |
48c0b101a9de
manifest: add fastdelta method to manifestdict
Augie Fackler <raf@durin42.com>
parents:
22930
diff
changeset
|
659 addbuf = util.buffer(base) |
48c0b101a9de
manifest: add fastdelta method to manifestdict
Augie Fackler <raf@durin42.com>
parents:
22930
diff
changeset
|
660 |
26871
1cbf144fd8a1
manifest: skip fastdelta if the change is large
Durham Goode <durham@fb.com>
parents:
26402
diff
changeset
|
661 changes = list(changes) |
42376
89c0c8edc9d4
tests: demonstrate broken manifest generation with the pure module
Matt Harbison <matt_harbison@yahoo.com>
parents:
41965
diff
changeset
|
662 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
|
663 # 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
|
664 # each line and creates the deltas |
1cbf144fd8a1
manifest: skip fastdelta if the change is large
Durham Goode <durham@fb.com>
parents:
26402
diff
changeset
|
665 for f, todelete in changes: |
1cbf144fd8a1
manifest: skip fastdelta if the change is large
Durham Goode <durham@fb.com>
parents:
26402
diff
changeset
|
666 # 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
|
667 start, end = _msearch(addbuf, f, start) |
1cbf144fd8a1
manifest: skip fastdelta if the change is large
Durham Goode <durham@fb.com>
parents:
26402
diff
changeset
|
668 if not todelete: |
1cbf144fd8a1
manifest: skip fastdelta if the change is large
Durham Goode <durham@fb.com>
parents:
26402
diff
changeset
|
669 h, fl = self._lm[f] |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
670 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
|
671 else: |
1cbf144fd8a1
manifest: skip fastdelta if the change is large
Durham Goode <durham@fb.com>
parents:
26402
diff
changeset
|
672 if start == end: |
1cbf144fd8a1
manifest: skip fastdelta if the change is large
Durham Goode <durham@fb.com>
parents:
26402
diff
changeset
|
673 # 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
|
674 raise AssertionError( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
675 _(b"failed to remove %s from manifest") % f |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
676 ) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
677 l = b"" |
26871
1cbf144fd8a1
manifest: skip fastdelta if the change is large
Durham Goode <durham@fb.com>
parents:
26402
diff
changeset
|
678 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
|
679 if dend < end: |
1cbf144fd8a1
manifest: skip fastdelta if the change is large
Durham Goode <durham@fb.com>
parents:
26402
diff
changeset
|
680 dend = end |
1cbf144fd8a1
manifest: skip fastdelta if the change is large
Durham Goode <durham@fb.com>
parents:
26402
diff
changeset
|
681 if l: |
1cbf144fd8a1
manifest: skip fastdelta if the change is large
Durham Goode <durham@fb.com>
parents:
26402
diff
changeset
|
682 dline.append(l) |
1cbf144fd8a1
manifest: skip fastdelta if the change is large
Durham Goode <durham@fb.com>
parents:
26402
diff
changeset
|
683 else: |
1cbf144fd8a1
manifest: skip fastdelta if the change is large
Durham Goode <durham@fb.com>
parents:
26402
diff
changeset
|
684 if dstart is not None: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
685 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
|
686 dstart = start |
22931
48c0b101a9de
manifest: add fastdelta method to manifestdict
Augie Fackler <raf@durin42.com>
parents:
22930
diff
changeset
|
687 dend = end |
26871
1cbf144fd8a1
manifest: skip fastdelta if the change is large
Durham Goode <durham@fb.com>
parents:
26402
diff
changeset
|
688 dline = [l] |
22931
48c0b101a9de
manifest: add fastdelta method to manifestdict
Augie Fackler <raf@durin42.com>
parents:
22930
diff
changeset
|
689 |
26871
1cbf144fd8a1
manifest: skip fastdelta if the change is large
Durham Goode <durham@fb.com>
parents:
26402
diff
changeset
|
690 if dstart is not None: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
691 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
|
692 # 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
|
693 deltatext, arraytext = _addlistdelta(base, delta) |
1cbf144fd8a1
manifest: skip fastdelta if the change is large
Durham Goode <durham@fb.com>
parents:
26402
diff
changeset
|
694 else: |
1cbf144fd8a1
manifest: skip fastdelta if the change is large
Durham Goode <durham@fb.com>
parents:
26402
diff
changeset
|
695 # 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
|
696 # diff it. |
31346
2a18e9e6ca43
py3: use bytearray() instead of array('c', ...) constructions
Augie Fackler <augie@google.com>
parents:
31294
diff
changeset
|
697 arraytext = bytearray(self.text()) |
2a18e9e6ca43
py3: use bytearray() instead of array('c', ...) constructions
Augie Fackler <augie@google.com>
parents:
31294
diff
changeset
|
698 deltatext = mdiff.textdiff( |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
699 util.buffer(base), util.buffer(arraytext) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
700 ) |
26871
1cbf144fd8a1
manifest: skip fastdelta if the change is large
Durham Goode <durham@fb.com>
parents:
26402
diff
changeset
|
701 |
22931
48c0b101a9de
manifest: add fastdelta method to manifestdict
Augie Fackler <raf@durin42.com>
parents:
22930
diff
changeset
|
702 return arraytext, deltatext |
48c0b101a9de
manifest: add fastdelta method to manifestdict
Augie Fackler <raf@durin42.com>
parents:
22930
diff
changeset
|
703 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
704 |
22930
1acb81d10eaf
manifest: move _search to module level and rename to _msearch
Augie Fackler <raf@durin42.com>
parents:
22929
diff
changeset
|
705 def _msearch(m, s, lo=0, hi=None): |
1acb81d10eaf
manifest: move _search to module level and rename to _msearch
Augie Fackler <raf@durin42.com>
parents:
22929
diff
changeset
|
706 '''return a tuple (start, end) that says where to find s within m. |
1acb81d10eaf
manifest: move _search to module level and rename to _msearch
Augie Fackler <raf@durin42.com>
parents:
22929
diff
changeset
|
707 |
1acb81d10eaf
manifest: move _search to module level and rename to _msearch
Augie Fackler <raf@durin42.com>
parents:
22929
diff
changeset
|
708 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
|
709 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
|
710 they indicate the proper sorted insertion point. |
1acb81d10eaf
manifest: move _search to module level and rename to _msearch
Augie Fackler <raf@durin42.com>
parents:
22929
diff
changeset
|
711 |
31650
23391acfc421
py3: fix manifestdict.fastdelta() to be compatible with memoryview
Yuya Nishihara <yuya@tcha.org>
parents:
31531
diff
changeset
|
712 m should be a buffer, a memoryview or a byte string. |
23391acfc421
py3: fix manifestdict.fastdelta() to be compatible with memoryview
Yuya Nishihara <yuya@tcha.org>
parents:
31531
diff
changeset
|
713 s is a byte string''' |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
714 |
22930
1acb81d10eaf
manifest: move _search to module level and rename to _msearch
Augie Fackler <raf@durin42.com>
parents:
22929
diff
changeset
|
715 def advance(i, c): |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
716 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
|
717 i += 1 |
1acb81d10eaf
manifest: move _search to module level and rename to _msearch
Augie Fackler <raf@durin42.com>
parents:
22929
diff
changeset
|
718 return i |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
719 |
22930
1acb81d10eaf
manifest: move _search to module level and rename to _msearch
Augie Fackler <raf@durin42.com>
parents:
22929
diff
changeset
|
720 if not s: |
1acb81d10eaf
manifest: move _search to module level and rename to _msearch
Augie Fackler <raf@durin42.com>
parents:
22929
diff
changeset
|
721 return (lo, lo) |
1acb81d10eaf
manifest: move _search to module level and rename to _msearch
Augie Fackler <raf@durin42.com>
parents:
22929
diff
changeset
|
722 lenm = len(m) |
1acb81d10eaf
manifest: move _search to module level and rename to _msearch
Augie Fackler <raf@durin42.com>
parents:
22929
diff
changeset
|
723 if not hi: |
1acb81d10eaf
manifest: move _search to module level and rename to _msearch
Augie Fackler <raf@durin42.com>
parents:
22929
diff
changeset
|
724 hi = lenm |
1acb81d10eaf
manifest: move _search to module level and rename to _msearch
Augie Fackler <raf@durin42.com>
parents:
22929
diff
changeset
|
725 while lo < hi: |
1acb81d10eaf
manifest: move _search to module level and rename to _msearch
Augie Fackler <raf@durin42.com>
parents:
22929
diff
changeset
|
726 mid = (lo + hi) // 2 |
1acb81d10eaf
manifest: move _search to module level and rename to _msearch
Augie Fackler <raf@durin42.com>
parents:
22929
diff
changeset
|
727 start = mid |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
728 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
|
729 start -= 1 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
730 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
|
731 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
|
732 # 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
|
733 # 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
|
734 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
|
735 else: |
1acb81d10eaf
manifest: move _search to module level and rename to _msearch
Augie Fackler <raf@durin42.com>
parents:
22929
diff
changeset
|
736 # 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
|
737 hi = start |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
738 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
|
739 found = m[lo:end] |
1acb81d10eaf
manifest: move _search to module level and rename to _msearch
Augie Fackler <raf@durin42.com>
parents:
22929
diff
changeset
|
740 if s == found: |
1acb81d10eaf
manifest: move _search to module level and rename to _msearch
Augie Fackler <raf@durin42.com>
parents:
22929
diff
changeset
|
741 # 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
|
742 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
|
743 return (lo, end + 1) |
1acb81d10eaf
manifest: move _search to module level and rename to _msearch
Augie Fackler <raf@durin42.com>
parents:
22929
diff
changeset
|
744 else: |
1acb81d10eaf
manifest: move _search to module level and rename to _msearch
Augie Fackler <raf@durin42.com>
parents:
22929
diff
changeset
|
745 return (lo, lo) |
1acb81d10eaf
manifest: move _search to module level and rename to _msearch
Augie Fackler <raf@durin42.com>
parents:
22929
diff
changeset
|
746 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
747 |
22415
65ec6c5c0fb3
manifest: mark addlistdelta and checkforbidden as module-private
Augie Fackler <raf@durin42.com>
parents:
22409
diff
changeset
|
748 def _checkforbidden(l): |
22408
dc97e04c12ad
manifest: move checkforbidden to module-level
Augie Fackler <raf@durin42.com>
parents:
21879
diff
changeset
|
749 """Check filenames for illegal characters.""" |
dc97e04c12ad
manifest: move checkforbidden to module-level
Augie Fackler <raf@durin42.com>
parents:
21879
diff
changeset
|
750 for f in l: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
751 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
|
752 raise error.StorageError( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
753 _(b"'\\n' and '\\r' disallowed in filenames: %r") |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
754 % pycompat.bytestr(f) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
755 ) |
22408
dc97e04c12ad
manifest: move checkforbidden to module-level
Augie Fackler <raf@durin42.com>
parents:
21879
diff
changeset
|
756 |
dc97e04c12ad
manifest: move checkforbidden to module-level
Augie Fackler <raf@durin42.com>
parents:
21879
diff
changeset
|
757 |
22409
8f09b785b59b
manifest: move addlistdelta to module-level
Augie Fackler <raf@durin42.com>
parents:
22408
diff
changeset
|
758 # 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
|
759 # return a delta suitable for addrevision |
22415
65ec6c5c0fb3
manifest: mark addlistdelta and checkforbidden as module-private
Augie Fackler <raf@durin42.com>
parents:
22409
diff
changeset
|
760 def _addlistdelta(addlist, x): |
22409
8f09b785b59b
manifest: move addlistdelta to module-level
Augie Fackler <raf@durin42.com>
parents:
22408
diff
changeset
|
761 # 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
|
762 # than repeatedly modifying the existing one |
8f09b785b59b
manifest: move addlistdelta to module-level
Augie Fackler <raf@durin42.com>
parents:
22408
diff
changeset
|
763 currentposition = 0 |
31346
2a18e9e6ca43
py3: use bytearray() instead of array('c', ...) constructions
Augie Fackler <augie@google.com>
parents:
31294
diff
changeset
|
764 newaddlist = bytearray() |
22409
8f09b785b59b
manifest: move addlistdelta to module-level
Augie Fackler <raf@durin42.com>
parents:
22408
diff
changeset
|
765 |
8f09b785b59b
manifest: move addlistdelta to module-level
Augie Fackler <raf@durin42.com>
parents:
22408
diff
changeset
|
766 for start, end, content in x: |
8f09b785b59b
manifest: move addlistdelta to module-level
Augie Fackler <raf@durin42.com>
parents:
22408
diff
changeset
|
767 newaddlist += addlist[currentposition:start] |
8f09b785b59b
manifest: move addlistdelta to module-level
Augie Fackler <raf@durin42.com>
parents:
22408
diff
changeset
|
768 if content: |
31346
2a18e9e6ca43
py3: use bytearray() instead of array('c', ...) constructions
Augie Fackler <augie@google.com>
parents:
31294
diff
changeset
|
769 newaddlist += bytearray(content) |
22409
8f09b785b59b
manifest: move addlistdelta to module-level
Augie Fackler <raf@durin42.com>
parents:
22408
diff
changeset
|
770 |
8f09b785b59b
manifest: move addlistdelta to module-level
Augie Fackler <raf@durin42.com>
parents:
22408
diff
changeset
|
771 currentposition = end |
8f09b785b59b
manifest: move addlistdelta to module-level
Augie Fackler <raf@durin42.com>
parents:
22408
diff
changeset
|
772 |
8f09b785b59b
manifest: move addlistdelta to module-level
Augie Fackler <raf@durin42.com>
parents:
22408
diff
changeset
|
773 newaddlist += addlist[currentposition:] |
8f09b785b59b
manifest: move addlistdelta to module-level
Augie Fackler <raf@durin42.com>
parents:
22408
diff
changeset
|
774 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
775 deltatext = b"".join( |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
776 struct.pack(b">lll", start, end, len(content)) + content |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
777 for start, end, content in x |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
778 ) |
22409
8f09b785b59b
manifest: move addlistdelta to module-level
Augie Fackler <raf@durin42.com>
parents:
22408
diff
changeset
|
779 return deltatext, newaddlist |
8f09b785b59b
manifest: move addlistdelta to module-level
Augie Fackler <raf@durin42.com>
parents:
22408
diff
changeset
|
780 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
781 |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
782 def _splittopdir(f): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
783 if b'/' in f: |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
784 dir, subpath = f.split(b'/', 1) |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
785 return dir + b'/', subpath |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
786 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
787 return b'', f |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
788 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
789 |
26402
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
790 _noop = lambda s: None |
25222
0de132d5328a
treemanifest: lazily load manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
25221
diff
changeset
|
791 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
792 |
44664
8c66a680f396
manifest: also declare treemanifest as implementing imanifestdict
Augie Fackler <augie@google.com>
parents:
44663
diff
changeset
|
793 @interfaceutil.implementer(repository.imanifestdict) |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
794 class treemanifest(object): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
795 def __init__(self, dir=b'', text=b''): |
24403
0e23faa1511c
treemanifest: store directory path in treemanifest nodes
Martin von Zweigbergk <martinvonz@google.com>
parents:
24402
diff
changeset
|
796 self._dir = dir |
39316
53363a8eff57
manifest: don't go through revlog to access node symbols
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39315
diff
changeset
|
797 self._node = nullid |
26402
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
798 self._loadfunc = _noop |
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
799 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
|
800 self._dirty = False |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
801 self._dirs = {} |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
802 self._lazydirs = {} |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
803 # Using _lazymanifest here is a little slower than plain old dicts |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
804 self._files = {} |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
805 self._flags = {} |
25220
f0fbd88b21fb
treemanifest: speed up diff by keeping track of dirty nodes
Martin von Zweigbergk <martinvonz@google.com>
parents:
25188
diff
changeset
|
806 if text: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
807 |
25220
f0fbd88b21fb
treemanifest: speed up diff by keeping track of dirty nodes
Martin von Zweigbergk <martinvonz@google.com>
parents:
25188
diff
changeset
|
808 def readsubtree(subdir, subm): |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
809 raise AssertionError( |
43117
8ff1ecfadcd1
cleanup: join string literals that are already on one line
Martin von Zweigbergk <martinvonz@google.com>
parents:
43106
diff
changeset
|
810 b'treemanifest constructor only accepts flat manifests' |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
811 ) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
812 |
25220
f0fbd88b21fb
treemanifest: speed up diff by keeping track of dirty nodes
Martin von Zweigbergk <martinvonz@google.com>
parents:
25188
diff
changeset
|
813 self.parse(text, readsubtree) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
814 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
|
815 |
24403
0e23faa1511c
treemanifest: store directory path in treemanifest nodes
Martin von Zweigbergk <martinvonz@google.com>
parents:
24402
diff
changeset
|
816 def _subpath(self, path): |
0e23faa1511c
treemanifest: store directory path in treemanifest nodes
Martin von Zweigbergk <martinvonz@google.com>
parents:
24402
diff
changeset
|
817 return self._dir + path |
0e23faa1511c
treemanifest: store directory path in treemanifest nodes
Martin von Zweigbergk <martinvonz@google.com>
parents:
24402
diff
changeset
|
818 |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
819 def _loadalllazy(self): |
40039
a0c18b271ea1
treemanifests: store whether a lazydirs entry needs copied after materializing
spectral <spectral@google.com>
parents:
40038
diff
changeset
|
820 selfdirs = self._dirs |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43089
diff
changeset
|
821 for d, (path, node, readsubtree, docopy) in pycompat.iteritems( |
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43089
diff
changeset
|
822 self._lazydirs |
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43089
diff
changeset
|
823 ): |
40039
a0c18b271ea1
treemanifests: store whether a lazydirs entry needs copied after materializing
spectral <spectral@google.com>
parents:
40038
diff
changeset
|
824 if docopy: |
a0c18b271ea1
treemanifests: store whether a lazydirs entry needs copied after materializing
spectral <spectral@google.com>
parents:
40038
diff
changeset
|
825 selfdirs[d] = readsubtree(path, node).copy() |
a0c18b271ea1
treemanifests: store whether a lazydirs entry needs copied after materializing
spectral <spectral@google.com>
parents:
40038
diff
changeset
|
826 else: |
a0c18b271ea1
treemanifests: store whether a lazydirs entry needs copied after materializing
spectral <spectral@google.com>
parents:
40038
diff
changeset
|
827 selfdirs[d] = readsubtree(path, node) |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
828 self._lazydirs = {} |
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
829 |
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
830 def _loadlazy(self, d): |
39981
da0319e024c0
treemanifests: make _loadlazy tolerate item not on _lazydirs
spectral <spectral@google.com>
parents:
39869
diff
changeset
|
831 v = self._lazydirs.get(d) |
da0319e024c0
treemanifests: make _loadlazy tolerate item not on _lazydirs
spectral <spectral@google.com>
parents:
39869
diff
changeset
|
832 if v: |
40039
a0c18b271ea1
treemanifests: store whether a lazydirs entry needs copied after materializing
spectral <spectral@google.com>
parents:
40038
diff
changeset
|
833 path, node, readsubtree, docopy = v |
a0c18b271ea1
treemanifests: store whether a lazydirs entry needs copied after materializing
spectral <spectral@google.com>
parents:
40038
diff
changeset
|
834 if docopy: |
a0c18b271ea1
treemanifests: store whether a lazydirs entry needs copied after materializing
spectral <spectral@google.com>
parents:
40038
diff
changeset
|
835 self._dirs[d] = readsubtree(path, node).copy() |
a0c18b271ea1
treemanifests: store whether a lazydirs entry needs copied after materializing
spectral <spectral@google.com>
parents:
40038
diff
changeset
|
836 else: |
a0c18b271ea1
treemanifests: store whether a lazydirs entry needs copied after materializing
spectral <spectral@google.com>
parents:
40038
diff
changeset
|
837 self._dirs[d] = readsubtree(path, node) |
39981
da0319e024c0
treemanifests: make _loadlazy tolerate item not on _lazydirs
spectral <spectral@google.com>
parents:
39869
diff
changeset
|
838 del self._lazydirs[d] |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
839 |
39521
154e4f84b51c
treemanifest: use visitchildrenset when filtering a manifest to a matcher
Kyle Lippincott <spectral@google.com>
parents:
39518
diff
changeset
|
840 def _loadchildrensetlazy(self, visit): |
154e4f84b51c
treemanifest: use visitchildrenset when filtering a manifest to a matcher
Kyle Lippincott <spectral@google.com>
parents:
39518
diff
changeset
|
841 if not visit: |
154e4f84b51c
treemanifest: use visitchildrenset when filtering a manifest to a matcher
Kyle Lippincott <spectral@google.com>
parents:
39518
diff
changeset
|
842 return None |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
843 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
|
844 self._loadalllazy() |
154e4f84b51c
treemanifest: use visitchildrenset when filtering a manifest to a matcher
Kyle Lippincott <spectral@google.com>
parents:
39518
diff
changeset
|
845 return None |
154e4f84b51c
treemanifest: use visitchildrenset when filtering a manifest to a matcher
Kyle Lippincott <spectral@google.com>
parents:
39518
diff
changeset
|
846 |
39982
19103e68a698
treemanifests: make _loadchildrensetlazy just call _loadlazy
spectral <spectral@google.com>
parents:
39981
diff
changeset
|
847 loadlazy = self._loadlazy |
39521
154e4f84b51c
treemanifest: use visitchildrenset when filtering a manifest to a matcher
Kyle Lippincott <spectral@google.com>
parents:
39518
diff
changeset
|
848 for k in visit: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
849 loadlazy(k + b'/') |
39521
154e4f84b51c
treemanifest: use visitchildrenset when filtering a manifest to a matcher
Kyle Lippincott <spectral@google.com>
parents:
39518
diff
changeset
|
850 return visit |
154e4f84b51c
treemanifest: use visitchildrenset when filtering a manifest to a matcher
Kyle Lippincott <spectral@google.com>
parents:
39518
diff
changeset
|
851 |
40038
906c95073ff7
treemanifests: extract _loaddifflazy from _diff, use in _filesnotin
spectral <spectral@google.com>
parents:
39987
diff
changeset
|
852 def _loaddifflazy(self, t1, t2): |
906c95073ff7
treemanifests: extract _loaddifflazy from _diff, use in _filesnotin
spectral <spectral@google.com>
parents:
39987
diff
changeset
|
853 """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
|
854 |
906c95073ff7
treemanifests: extract _loaddifflazy from _diff, use in _filesnotin
spectral <spectral@google.com>
parents:
39987
diff
changeset
|
855 The criteria currently is: |
906c95073ff7
treemanifests: extract _loaddifflazy from _diff, use in _filesnotin
spectral <spectral@google.com>
parents:
39987
diff
changeset
|
856 - 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
|
857 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
|
858 - 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
|
859 differs, load it in both |
906c95073ff7
treemanifests: extract _loaddifflazy from _diff, use in _filesnotin
spectral <spectral@google.com>
parents:
39987
diff
changeset
|
860 """ |
906c95073ff7
treemanifests: extract _loaddifflazy from _diff, use in _filesnotin
spectral <spectral@google.com>
parents:
39987
diff
changeset
|
861 toloadlazy = [] |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43089
diff
changeset
|
862 for d, v1 in pycompat.iteritems(t1._lazydirs): |
40038
906c95073ff7
treemanifests: extract _loaddifflazy from _diff, use in _filesnotin
spectral <spectral@google.com>
parents:
39987
diff
changeset
|
863 v2 = t2._lazydirs.get(d) |
906c95073ff7
treemanifests: extract _loaddifflazy from _diff, use in _filesnotin
spectral <spectral@google.com>
parents:
39987
diff
changeset
|
864 if not v2 or v2[1] != v1[1]: |
906c95073ff7
treemanifests: extract _loaddifflazy from _diff, use in _filesnotin
spectral <spectral@google.com>
parents:
39987
diff
changeset
|
865 toloadlazy.append(d) |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43089
diff
changeset
|
866 for d, v1 in pycompat.iteritems(t2._lazydirs): |
40038
906c95073ff7
treemanifests: extract _loaddifflazy from _diff, use in _filesnotin
spectral <spectral@google.com>
parents:
39987
diff
changeset
|
867 if d not in t1._lazydirs: |
906c95073ff7
treemanifests: extract _loaddifflazy from _diff, use in _filesnotin
spectral <spectral@google.com>
parents:
39987
diff
changeset
|
868 toloadlazy.append(d) |
906c95073ff7
treemanifests: extract _loaddifflazy from _diff, use in _filesnotin
spectral <spectral@google.com>
parents:
39987
diff
changeset
|
869 |
906c95073ff7
treemanifests: extract _loaddifflazy from _diff, use in _filesnotin
spectral <spectral@google.com>
parents:
39987
diff
changeset
|
870 for d in toloadlazy: |
906c95073ff7
treemanifests: extract _loaddifflazy from _diff, use in _filesnotin
spectral <spectral@google.com>
parents:
39987
diff
changeset
|
871 t1._loadlazy(d) |
906c95073ff7
treemanifests: extract _loaddifflazy from _diff, use in _filesnotin
spectral <spectral@google.com>
parents:
39987
diff
changeset
|
872 t2._loadlazy(d) |
906c95073ff7
treemanifests: extract _loaddifflazy from _diff, use in _filesnotin
spectral <spectral@google.com>
parents:
39987
diff
changeset
|
873 |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
874 def __len__(self): |
25222
0de132d5328a
treemanifest: lazily load manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
25221
diff
changeset
|
875 self._load() |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
876 size = len(self._files) |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
877 self._loadalllazy() |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
878 for m in self._dirs.values(): |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
879 size += m.__len__() |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
880 return size |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
881 |
36174
b42c47b8c9d4
treemanifest: add an optimized __nonzero__()
Martin von Zweigbergk <martinvonz@google.com>
parents:
36095
diff
changeset
|
882 def __nonzero__(self): |
b42c47b8c9d4
treemanifest: add an optimized __nonzero__()
Martin von Zweigbergk <martinvonz@google.com>
parents:
36095
diff
changeset
|
883 # Faster than "__len() != 0" since it avoids loading sub-manifests |
b42c47b8c9d4
treemanifest: add an optimized __nonzero__()
Martin von Zweigbergk <martinvonz@google.com>
parents:
36095
diff
changeset
|
884 return not self._isempty() |
b42c47b8c9d4
treemanifest: add an optimized __nonzero__()
Martin von Zweigbergk <martinvonz@google.com>
parents:
36095
diff
changeset
|
885 |
b42c47b8c9d4
treemanifest: add an optimized __nonzero__()
Martin von Zweigbergk <martinvonz@google.com>
parents:
36095
diff
changeset
|
886 __bool__ = __nonzero__ |
b42c47b8c9d4
treemanifest: add an optimized __nonzero__()
Martin von Zweigbergk <martinvonz@google.com>
parents:
36095
diff
changeset
|
887 |
24551
4fdf5eac5b39
treemanifest: add treemanifest._isempty()
Drew Gottlieb <drgott@google.com>
parents:
24550
diff
changeset
|
888 def _isempty(self): |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
889 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
|
890 # See if we can skip loading everything. |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
891 if self._files or ( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
892 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
|
893 ): |
39516
079d7bfa463d
treemanifest: attempt to avoid loading all lazily-loaded subdirs in _isempty
Kyle Lippincott <spectral@google.com>
parents:
39515
diff
changeset
|
894 return False |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
895 self._loadalllazy() |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
896 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
|
897 |
44247
c443b9ba6f63
py3: __repr__ needs to return str, not bytes
Kyle Lippincott <spectral@google.com>
parents:
43778
diff
changeset
|
898 @encoding.strmethod |
26400
6f9d9e2a661f
manifest: add id(self) to treemanifest __repr__
Augie Fackler <augie@google.com>
parents:
26199
diff
changeset
|
899 def __repr__(self): |
43346
6ada8a274b9c
formatting: run black version 19.10b0 on the codebase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43117
diff
changeset
|
900 return ( |
44247
c443b9ba6f63
py3: __repr__ needs to return str, not bytes
Kyle Lippincott <spectral@google.com>
parents:
43778
diff
changeset
|
901 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
|
902 % ( |
6ada8a274b9c
formatting: run black version 19.10b0 on the codebase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43117
diff
changeset
|
903 self._dir, |
6ada8a274b9c
formatting: run black version 19.10b0 on the codebase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43117
diff
changeset
|
904 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
|
905 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
|
906 self._dirty, |
6ada8a274b9c
formatting: run black version 19.10b0 on the codebase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43117
diff
changeset
|
907 id(self), |
6ada8a274b9c
formatting: run black version 19.10b0 on the codebase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43117
diff
changeset
|
908 ) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
909 ) |
25091
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
910 |
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
911 def dir(self): |
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
912 '''The directory that this tree manifest represents, including a |
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
913 trailing '/'. Empty string for the repo root directory.''' |
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
914 return self._dir |
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
915 |
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
916 def node(self): |
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
917 '''This node of this instance. nullid for unsaved instances. Should |
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
918 be updated when the instance is read or written from a revlog. |
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
919 ''' |
25220
f0fbd88b21fb
treemanifest: speed up diff by keeping track of dirty nodes
Martin von Zweigbergk <martinvonz@google.com>
parents:
25188
diff
changeset
|
920 assert not self._dirty |
25091
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
921 return self._node |
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
922 |
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
923 def setnode(self, node): |
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
924 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
|
925 self._dirty = False |
24403
0e23faa1511c
treemanifest: store directory path in treemanifest nodes
Martin von Zweigbergk <martinvonz@google.com>
parents:
24402
diff
changeset
|
926 |
28206
8ab91d9290ce
treemanifest: implement iterentries()
Martin von Zweigbergk <martinvonz@google.com>
parents:
28203
diff
changeset
|
927 def iterentries(self): |
8ab91d9290ce
treemanifest: implement iterentries()
Martin von Zweigbergk <martinvonz@google.com>
parents:
28203
diff
changeset
|
928 self._load() |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
929 self._loadalllazy() |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
930 for p, n in sorted( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
931 itertools.chain(self._dirs.items(), self._files.items()) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
932 ): |
28206
8ab91d9290ce
treemanifest: implement iterentries()
Martin von Zweigbergk <martinvonz@google.com>
parents:
28203
diff
changeset
|
933 if p in self._files: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
934 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
|
935 else: |
8ab91d9290ce
treemanifest: implement iterentries()
Martin von Zweigbergk <martinvonz@google.com>
parents:
28203
diff
changeset
|
936 for x in n.iterentries(): |
8ab91d9290ce
treemanifest: implement iterentries()
Martin von Zweigbergk <martinvonz@google.com>
parents:
28203
diff
changeset
|
937 yield x |
8ab91d9290ce
treemanifest: implement iterentries()
Martin von Zweigbergk <martinvonz@google.com>
parents:
28203
diff
changeset
|
938 |
32550
b98199a5c3e1
cleanup: rename all iteritems methods to items and add iteritems alias
Augie Fackler <raf@durin42.com>
parents:
32536
diff
changeset
|
939 def items(self): |
25222
0de132d5328a
treemanifest: lazily load manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
25221
diff
changeset
|
940 self._load() |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
941 self._loadalllazy() |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
942 for p, n in sorted( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
943 itertools.chain(self._dirs.items(), self._files.items()) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
944 ): |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
945 if p in self._files: |
24403
0e23faa1511c
treemanifest: store directory path in treemanifest nodes
Martin von Zweigbergk <martinvonz@google.com>
parents:
24402
diff
changeset
|
946 yield self._subpath(p), n |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
947 else: |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43089
diff
changeset
|
948 for f, sn in pycompat.iteritems(n): |
24403
0e23faa1511c
treemanifest: store directory path in treemanifest nodes
Martin von Zweigbergk <martinvonz@google.com>
parents:
24402
diff
changeset
|
949 yield f, sn |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
950 |
32550
b98199a5c3e1
cleanup: rename all iteritems methods to items and add iteritems alias
Augie Fackler <raf@durin42.com>
parents:
32536
diff
changeset
|
951 iteritems = items |
b98199a5c3e1
cleanup: rename all iteritems methods to items and add iteritems alias
Augie Fackler <raf@durin42.com>
parents:
32536
diff
changeset
|
952 |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
953 def iterkeys(self): |
25222
0de132d5328a
treemanifest: lazily load manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
25221
diff
changeset
|
954 self._load() |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
955 self._loadalllazy() |
32536
aa333c1982ab
manifest: use itertools.chain() instead of + for Python 3 compat
Augie Fackler <raf@durin42.com>
parents:
32535
diff
changeset
|
956 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
|
957 if p in self._files: |
24403
0e23faa1511c
treemanifest: store directory path in treemanifest nodes
Martin von Zweigbergk <martinvonz@google.com>
parents:
24402
diff
changeset
|
958 yield self._subpath(p) |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
959 else: |
35586
fbf1a5d680ea
py3: don't use dict.iterkeys()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34345
diff
changeset
|
960 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
|
961 yield f |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
962 |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
963 def keys(self): |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
964 return list(self.iterkeys()) |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
965 |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
966 def __iter__(self): |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
967 return self.iterkeys() |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
968 |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
969 def __contains__(self, f): |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
970 if f is None: |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
971 return False |
25222
0de132d5328a
treemanifest: lazily load manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
25221
diff
changeset
|
972 self._load() |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
973 dir, subpath = _splittopdir(f) |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
974 if dir: |
39983
3cacb74c3a22
treemanifests: skip extraneous check for item before calling _loadlazy
spectral <spectral@google.com>
parents:
39982
diff
changeset
|
975 self._loadlazy(dir) |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
976 |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
977 if dir not in self._dirs: |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
978 return False |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
979 |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
980 return self._dirs[dir].__contains__(subpath) |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
981 else: |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
982 return f in self._files |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
983 |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
984 def get(self, f, default=None): |
25222
0de132d5328a
treemanifest: lazily load manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
25221
diff
changeset
|
985 self._load() |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
986 dir, subpath = _splittopdir(f) |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
987 if dir: |
39983
3cacb74c3a22
treemanifests: skip extraneous check for item before calling _loadlazy
spectral <spectral@google.com>
parents:
39982
diff
changeset
|
988 self._loadlazy(dir) |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
989 |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
990 if dir not in self._dirs: |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
991 return default |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
992 return self._dirs[dir].get(subpath, default) |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
993 else: |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
994 return self._files.get(f, default) |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
995 |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
996 def __getitem__(self, f): |
25222
0de132d5328a
treemanifest: lazily load manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
25221
diff
changeset
|
997 self._load() |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
998 dir, subpath = _splittopdir(f) |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
999 if dir: |
39983
3cacb74c3a22
treemanifests: skip extraneous check for item before calling _loadlazy
spectral <spectral@google.com>
parents:
39982
diff
changeset
|
1000 self._loadlazy(dir) |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
1001 |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1002 return self._dirs[dir].__getitem__(subpath) |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1003 else: |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1004 return self._files[f] |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1005 |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1006 def flags(self, f): |
25222
0de132d5328a
treemanifest: lazily load manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
25221
diff
changeset
|
1007 self._load() |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1008 dir, subpath = _splittopdir(f) |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1009 if dir: |
39983
3cacb74c3a22
treemanifests: skip extraneous check for item before calling _loadlazy
spectral <spectral@google.com>
parents:
39982
diff
changeset
|
1010 self._loadlazy(dir) |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
1011 |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1012 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
|
1013 return b'' |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1014 return self._dirs[dir].flags(subpath) |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1015 else: |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
1016 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
|
1017 return b'' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1018 return self._flags.get(f, b'') |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1019 |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1020 def find(self, f): |
25222
0de132d5328a
treemanifest: lazily load manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
25221
diff
changeset
|
1021 self._load() |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1022 dir, subpath = _splittopdir(f) |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1023 if dir: |
39983
3cacb74c3a22
treemanifests: skip extraneous check for item before calling _loadlazy
spectral <spectral@google.com>
parents:
39982
diff
changeset
|
1024 self._loadlazy(dir) |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
1025 |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1026 return self._dirs[dir].find(subpath) |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1027 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1028 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
|
1029 |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1030 def __delitem__(self, f): |
25222
0de132d5328a
treemanifest: lazily load manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
25221
diff
changeset
|
1031 self._load() |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1032 dir, subpath = _splittopdir(f) |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1033 if dir: |
39983
3cacb74c3a22
treemanifests: skip extraneous check for item before calling _loadlazy
spectral <spectral@google.com>
parents:
39982
diff
changeset
|
1034 self._loadlazy(dir) |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
1035 |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1036 self._dirs[dir].__delitem__(subpath) |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1037 # If the directory is now empty, remove it |
24551
4fdf5eac5b39
treemanifest: add treemanifest._isempty()
Drew Gottlieb <drgott@google.com>
parents:
24550
diff
changeset
|
1038 if self._dirs[dir]._isempty(): |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1039 del self._dirs[dir] |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1040 else: |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1041 del self._files[f] |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1042 if f in self._flags: |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1043 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
|
1044 self._dirty = True |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1045 |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1046 def __setitem__(self, f, n): |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1047 assert n is not None |
25222
0de132d5328a
treemanifest: lazily load manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
25221
diff
changeset
|
1048 self._load() |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1049 dir, subpath = _splittopdir(f) |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1050 if dir: |
39983
3cacb74c3a22
treemanifests: skip extraneous check for item before calling _loadlazy
spectral <spectral@google.com>
parents:
39982
diff
changeset
|
1051 self._loadlazy(dir) |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1052 if dir not in self._dirs: |
24403
0e23faa1511c
treemanifest: store directory path in treemanifest nodes
Martin von Zweigbergk <martinvonz@google.com>
parents:
24402
diff
changeset
|
1053 self._dirs[dir] = treemanifest(self._subpath(dir)) |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1054 self._dirs[dir].__setitem__(subpath, n) |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1055 else: |
44703
0e99b876966a
manifest: teach treemanifest about long hashes
Augie Fackler <augie@google.com>
parents:
44701
diff
changeset
|
1056 # 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
|
1057 # 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
|
1058 # sometimes extra bytes were added. |
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
1059 assert len(n) in (20, 32) |
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
1060 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
|
1061 self._dirty = True |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1062 |
26402
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1063 def _load(self): |
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1064 if self._loadfunc is not _noop: |
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1065 lf, self._loadfunc = self._loadfunc, _noop |
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1066 lf(self) |
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1067 elif self._copyfunc is not _noop: |
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1068 cf, self._copyfunc = self._copyfunc, _noop |
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1069 cf(self) |
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1070 |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1071 def setflag(self, f, flags): |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1072 """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
|
1073 if flags not in _manifestflags: |
d0ef8c1dddd4
manifest: tigher manifest parsing and flag use
Joerg Sonnenberger <joerg@bec.de>
parents:
45066
diff
changeset
|
1074 raise TypeError(b"Invalid manifest flag set.") |
25222
0de132d5328a
treemanifest: lazily load manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
25221
diff
changeset
|
1075 self._load() |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1076 dir, subpath = _splittopdir(f) |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1077 if dir: |
39983
3cacb74c3a22
treemanifests: skip extraneous check for item before calling _loadlazy
spectral <spectral@google.com>
parents:
39982
diff
changeset
|
1078 self._loadlazy(dir) |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1079 if dir not in self._dirs: |
24403
0e23faa1511c
treemanifest: store directory path in treemanifest nodes
Martin von Zweigbergk <martinvonz@google.com>
parents:
24402
diff
changeset
|
1080 self._dirs[dir] = treemanifest(self._subpath(dir)) |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1081 self._dirs[dir].setflag(subpath, flags) |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1082 else: |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1083 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
|
1084 self._dirty = True |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1085 |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1086 def copy(self): |
24403
0e23faa1511c
treemanifest: store directory path in treemanifest nodes
Martin von Zweigbergk <martinvonz@google.com>
parents:
24402
diff
changeset
|
1087 copy = treemanifest(self._dir) |
25091
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
1088 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
|
1089 copy._dirty = self._dirty |
26402
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1090 if self._copyfunc is _noop: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1091 |
26402
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1092 def _copyfunc(s): |
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1093 self._load() |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1094 s._lazydirs = { |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1095 d: (p, n, r, True) |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43089
diff
changeset
|
1096 for d, (p, n, r, c) in pycompat.iteritems(self._lazydirs) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1097 } |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
1098 sdirs = s._dirs |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43089
diff
changeset
|
1099 for d, v in pycompat.iteritems(self._dirs): |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
1100 sdirs[d] = v.copy() |
26402
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1101 s._files = dict.copy(self._files) |
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1102 s._flags = dict.copy(self._flags) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1103 |
26402
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1104 if self._loadfunc is _noop: |
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1105 _copyfunc(copy) |
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1106 else: |
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1107 copy._copyfunc = _copyfunc |
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1108 else: |
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1109 copy._copyfunc = self._copyfunc |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1110 return copy |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1111 |
31255
959ebff3505a
manifest: add match argument to diff and filesnotin
Durham Goode <durham@fb.com>
parents:
31153
diff
changeset
|
1112 def filesnotin(self, m2, match=None): |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1113 '''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
|
1114 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
|
1115 m1 = self._matches(match) |
0bf3b5e80d30
manifest: move matches method to be outside the interface
Augie Fackler <augie@google.com>
parents:
44286
diff
changeset
|
1116 m2 = m2._matches(match) |
31255
959ebff3505a
manifest: add match argument to diff and filesnotin
Durham Goode <durham@fb.com>
parents:
31153
diff
changeset
|
1117 return m1.filesnotin(m2) |
959ebff3505a
manifest: add match argument to diff and filesnotin
Durham Goode <durham@fb.com>
parents:
31153
diff
changeset
|
1118 |
24405
cbe9d50d9e65
treemanifest: make filesnotin() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24404
diff
changeset
|
1119 files = set() |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1120 |
24405
cbe9d50d9e65
treemanifest: make filesnotin() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24404
diff
changeset
|
1121 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
|
1122 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
|
1123 return |
25222
0de132d5328a
treemanifest: lazily load manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
25221
diff
changeset
|
1124 t1._load() |
0de132d5328a
treemanifest: lazily load manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
25221
diff
changeset
|
1125 t2._load() |
40038
906c95073ff7
treemanifests: extract _loaddifflazy from _diff, use in _filesnotin
spectral <spectral@google.com>
parents:
39987
diff
changeset
|
1126 self._loaddifflazy(t1, t2) |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43089
diff
changeset
|
1127 for d, m1 in pycompat.iteritems(t1._dirs): |
24405
cbe9d50d9e65
treemanifest: make filesnotin() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24404
diff
changeset
|
1128 if d in t2._dirs: |
cbe9d50d9e65
treemanifest: make filesnotin() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24404
diff
changeset
|
1129 m2 = t2._dirs[d] |
cbe9d50d9e65
treemanifest: make filesnotin() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24404
diff
changeset
|
1130 _filesnotin(m1, m2) |
cbe9d50d9e65
treemanifest: make filesnotin() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24404
diff
changeset
|
1131 else: |
cbe9d50d9e65
treemanifest: make filesnotin() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24404
diff
changeset
|
1132 files.update(m1.iterkeys()) |
cbe9d50d9e65
treemanifest: make filesnotin() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24404
diff
changeset
|
1133 |
36300
413c179cf7d5
manifest: correct the one use of iterkeys() on a dict
Augie Fackler <augie@google.com>
parents:
36174
diff
changeset
|
1134 for fn in t1._files: |
24405
cbe9d50d9e65
treemanifest: make filesnotin() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24404
diff
changeset
|
1135 if fn not in t2._files: |
cbe9d50d9e65
treemanifest: make filesnotin() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24404
diff
changeset
|
1136 files.add(t1._subpath(fn)) |
cbe9d50d9e65
treemanifest: make filesnotin() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24404
diff
changeset
|
1137 |
cbe9d50d9e65
treemanifest: make filesnotin() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24404
diff
changeset
|
1138 _filesnotin(self, m2) |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1139 return files |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1140 |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1141 @propertycache |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1142 def _alldirs(self): |
43523
c21aca51b392
utils: move the `dirs` definition in pathutil (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43506
diff
changeset
|
1143 return pathutil.dirs(self) |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1144 |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1145 def dirs(self): |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1146 return self._alldirs |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1147 |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1148 def hasdir(self, dir): |
25222
0de132d5328a
treemanifest: lazily load manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
25221
diff
changeset
|
1149 self._load() |
24406
1297480ed347
treemanifest: make hasdir() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24405
diff
changeset
|
1150 topdir, subdir = _splittopdir(dir) |
1297480ed347
treemanifest: make hasdir() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24405
diff
changeset
|
1151 if topdir: |
39983
3cacb74c3a22
treemanifests: skip extraneous check for item before calling _loadlazy
spectral <spectral@google.com>
parents:
39982
diff
changeset
|
1152 self._loadlazy(topdir) |
24406
1297480ed347
treemanifest: make hasdir() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24405
diff
changeset
|
1153 if topdir in self._dirs: |
1297480ed347
treemanifest: make hasdir() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24405
diff
changeset
|
1154 return self._dirs[topdir].hasdir(subdir) |
1297480ed347
treemanifest: make hasdir() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24405
diff
changeset
|
1155 return False |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1156 dirslash = dir + b'/' |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
1157 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
|
1158 |
24646
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
1159 def walk(self, match): |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
1160 '''Generates matching file names. |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
1161 |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
1162 It also reports nonexistent files by marking them bad with match.bad(). |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
1163 ''' |
24683
4eaea0ed8dc1
manifest.walk: special-case match.always() for speed
Martin von Zweigbergk <martinvonz@google.com>
parents:
24682
diff
changeset
|
1164 if match.always(): |
4eaea0ed8dc1
manifest.walk: special-case match.always() for speed
Martin von Zweigbergk <martinvonz@google.com>
parents:
24682
diff
changeset
|
1165 for f in iter(self): |
4eaea0ed8dc1
manifest.walk: special-case match.always() for speed
Martin von Zweigbergk <martinvonz@google.com>
parents:
24682
diff
changeset
|
1166 yield f |
4eaea0ed8dc1
manifest.walk: special-case match.always() for speed
Martin von Zweigbergk <martinvonz@google.com>
parents:
24682
diff
changeset
|
1167 return |
4eaea0ed8dc1
manifest.walk: special-case match.always() for speed
Martin von Zweigbergk <martinvonz@google.com>
parents:
24682
diff
changeset
|
1168 |
24646
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
1169 fset = set(match.files()) |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
1170 |
24647
fb446c57f8f9
treemanifest: refactor treemanifest.walk()
Drew Gottlieb <drgott@google.com>
parents:
24646
diff
changeset
|
1171 for fn in self._walk(match): |
24646
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
1172 if fn in fset: |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
1173 # specified pattern is the exact name |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
1174 fset.remove(fn) |
24647
fb446c57f8f9
treemanifest: refactor treemanifest.walk()
Drew Gottlieb <drgott@google.com>
parents:
24646
diff
changeset
|
1175 yield fn |
24646
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
1176 |
42341
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41965
diff
changeset
|
1177 # 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
|
1178 # follow that here, too |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1179 fset.discard(b'') |
24646
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
1180 |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
1181 for fn in sorted(fset): |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
1182 if not self.hasdir(fn): |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
1183 match.bad(fn, None) |
5693c834bcb4
manifest: move changectx.walk() to manifests
Drew Gottlieb <drgott@google.com>
parents:
24636
diff
changeset
|
1184 |
25188
2773540c3650
match: remove unnecessary optimization where visitdir() returns 'all'
Drew Gottlieb <drgott@google.com>
parents:
25185
diff
changeset
|
1185 def _walk(self, match): |
2773540c3650
match: remove unnecessary optimization where visitdir() returns 'all'
Drew Gottlieb <drgott@google.com>
parents:
25185
diff
changeset
|
1186 '''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
|
1187 visit = match.visitchildrenset(self._dir[:-1]) |
39522
3ba9ef0fb693
treemanifest: use visitchildrenset when doing a walk
Kyle Lippincott <spectral@google.com>
parents:
39521
diff
changeset
|
1188 if not visit: |
25188
2773540c3650
match: remove unnecessary optimization where visitdir() returns 'all'
Drew Gottlieb <drgott@google.com>
parents:
25185
diff
changeset
|
1189 return |
24647
fb446c57f8f9
treemanifest: refactor treemanifest.walk()
Drew Gottlieb <drgott@google.com>
parents:
24646
diff
changeset
|
1190 |
fb446c57f8f9
treemanifest: refactor treemanifest.walk()
Drew Gottlieb <drgott@google.com>
parents:
24646
diff
changeset
|
1191 # 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
|
1192 self._load() |
39522
3ba9ef0fb693
treemanifest: use visitchildrenset when doing a walk
Kyle Lippincott <spectral@google.com>
parents:
39521
diff
changeset
|
1193 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
|
1194 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
|
1195 if p in self._files: |
fb446c57f8f9
treemanifest: refactor treemanifest.walk()
Drew Gottlieb <drgott@google.com>
parents:
24646
diff
changeset
|
1196 fullp = self._subpath(p) |
fb446c57f8f9
treemanifest: refactor treemanifest.walk()
Drew Gottlieb <drgott@google.com>
parents:
24646
diff
changeset
|
1197 if match(fullp): |
fb446c57f8f9
treemanifest: refactor treemanifest.walk()
Drew Gottlieb <drgott@google.com>
parents:
24646
diff
changeset
|
1198 yield fullp |
fb446c57f8f9
treemanifest: refactor treemanifest.walk()
Drew Gottlieb <drgott@google.com>
parents:
24646
diff
changeset
|
1199 else: |
39522
3ba9ef0fb693
treemanifest: use visitchildrenset when doing a walk
Kyle Lippincott <spectral@google.com>
parents:
39521
diff
changeset
|
1200 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
|
1201 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
|
1202 yield f |
24647
fb446c57f8f9
treemanifest: refactor treemanifest.walk()
Drew Gottlieb <drgott@google.com>
parents:
24646
diff
changeset
|
1203 |
25188
2773540c3650
match: remove unnecessary optimization where visitdir() returns 'all'
Drew Gottlieb <drgott@google.com>
parents:
25185
diff
changeset
|
1204 def _matches(self, match): |
24552
a2292da6d821
treemanifest: make treemanifest.matches() faster
Drew Gottlieb <drgott@google.com>
parents:
24551
diff
changeset
|
1205 '''recursively generate a new manifest filtered by the match argument. |
25188
2773540c3650
match: remove unnecessary optimization where visitdir() returns 'all'
Drew Gottlieb <drgott@google.com>
parents:
25185
diff
changeset
|
1206 ''' |
44352
0bf3b5e80d30
manifest: move matches method to be outside the interface
Augie Fackler <augie@google.com>
parents:
44286
diff
changeset
|
1207 if match.always(): |
0bf3b5e80d30
manifest: move matches method to be outside the interface
Augie Fackler <augie@google.com>
parents:
44286
diff
changeset
|
1208 return self.copy() |
0bf3b5e80d30
manifest: move matches method to be outside the interface
Augie Fackler <augie@google.com>
parents:
44286
diff
changeset
|
1209 return self._matches_inner(match) |
0bf3b5e80d30
manifest: move matches method to be outside the interface
Augie Fackler <augie@google.com>
parents:
44286
diff
changeset
|
1210 |
0bf3b5e80d30
manifest: move matches method to be outside the interface
Augie Fackler <augie@google.com>
parents:
44286
diff
changeset
|
1211 def _matches_inner(self, match): |
0bf3b5e80d30
manifest: move matches method to be outside the interface
Augie Fackler <augie@google.com>
parents:
44286
diff
changeset
|
1212 if match.always(): |
0bf3b5e80d30
manifest: move matches method to be outside the interface
Augie Fackler <augie@google.com>
parents:
44286
diff
changeset
|
1213 return self.copy() |
27343
c59647c6694d
treemanifest: don't iterate entire matching submanifests on match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
27271
diff
changeset
|
1214 |
42341
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41965
diff
changeset
|
1215 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
|
1216 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
|
1217 return self.copy() |
24552
a2292da6d821
treemanifest: make treemanifest.matches() faster
Drew Gottlieb <drgott@google.com>
parents:
24551
diff
changeset
|
1218 ret = treemanifest(self._dir) |
27343
c59647c6694d
treemanifest: don't iterate entire matching submanifests on match()
Martin von Zweigbergk <martinvonz@google.com>
parents:
27271
diff
changeset
|
1219 if not visit: |
25188
2773540c3650
match: remove unnecessary optimization where visitdir() returns 'all'
Drew Gottlieb <drgott@google.com>
parents:
25185
diff
changeset
|
1220 return ret |
24552
a2292da6d821
treemanifest: make treemanifest.matches() faster
Drew Gottlieb <drgott@google.com>
parents:
24551
diff
changeset
|
1221 |
25222
0de132d5328a
treemanifest: lazily load manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
25221
diff
changeset
|
1222 self._load() |
24552
a2292da6d821
treemanifest: make treemanifest.matches() faster
Drew Gottlieb <drgott@google.com>
parents:
24551
diff
changeset
|
1223 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
|
1224 # 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
|
1225 # 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
|
1226 # 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
|
1227 # 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
|
1228 # 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
|
1229 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
|
1230 continue |
24552
a2292da6d821
treemanifest: make treemanifest.matches() faster
Drew Gottlieb <drgott@google.com>
parents:
24551
diff
changeset
|
1231 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
|
1232 # 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
|
1233 # matcher code to further filter results. |
24552
a2292da6d821
treemanifest: make treemanifest.matches() faster
Drew Gottlieb <drgott@google.com>
parents:
24551
diff
changeset
|
1234 if not match(fullp): |
a2292da6d821
treemanifest: make treemanifest.matches() faster
Drew Gottlieb <drgott@google.com>
parents:
24551
diff
changeset
|
1235 continue |
a2292da6d821
treemanifest: make treemanifest.matches() faster
Drew Gottlieb <drgott@google.com>
parents:
24551
diff
changeset
|
1236 ret._files[fn] = self._files[fn] |
a2292da6d821
treemanifest: make treemanifest.matches() faster
Drew Gottlieb <drgott@google.com>
parents:
24551
diff
changeset
|
1237 if fn in self._flags: |
a2292da6d821
treemanifest: make treemanifest.matches() faster
Drew Gottlieb <drgott@google.com>
parents:
24551
diff
changeset
|
1238 ret._flags[fn] = self._flags[fn] |
a2292da6d821
treemanifest: make treemanifest.matches() faster
Drew Gottlieb <drgott@google.com>
parents:
24551
diff
changeset
|
1239 |
39521
154e4f84b51c
treemanifest: use visitchildrenset when filtering a manifest to a matcher
Kyle Lippincott <spectral@google.com>
parents:
39518
diff
changeset
|
1240 visit = self._loadchildrensetlazy(visit) |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43089
diff
changeset
|
1241 for dir, subm in pycompat.iteritems(self._dirs): |
39521
154e4f84b51c
treemanifest: use visitchildrenset when filtering a manifest to a matcher
Kyle Lippincott <spectral@google.com>
parents:
39518
diff
changeset
|
1242 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
|
1243 continue |
44352
0bf3b5e80d30
manifest: move matches method to be outside the interface
Augie Fackler <augie@google.com>
parents:
44286
diff
changeset
|
1244 m = subm._matches_inner(match) |
24552
a2292da6d821
treemanifest: make treemanifest.matches() faster
Drew Gottlieb <drgott@google.com>
parents:
24551
diff
changeset
|
1245 if not m._isempty(): |
a2292da6d821
treemanifest: make treemanifest.matches() faster
Drew Gottlieb <drgott@google.com>
parents:
24551
diff
changeset
|
1246 ret._dirs[dir] = m |
a2292da6d821
treemanifest: make treemanifest.matches() faster
Drew Gottlieb <drgott@google.com>
parents:
24551
diff
changeset
|
1247 |
25220
f0fbd88b21fb
treemanifest: speed up diff by keeping track of dirty nodes
Martin von Zweigbergk <martinvonz@google.com>
parents:
25188
diff
changeset
|
1248 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
|
1249 ret._dirty = True |
24552
a2292da6d821
treemanifest: make treemanifest.matches() faster
Drew Gottlieb <drgott@google.com>
parents:
24551
diff
changeset
|
1250 return ret |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1251 |
44663
948fac24bc39
manifest: introduce new exception to signal unavailability of fastdelta()
Augie Fackler <augie@google.com>
parents:
44352
diff
changeset
|
1252 def fastdelta(self, base, changes): |
948fac24bc39
manifest: introduce new exception to signal unavailability of fastdelta()
Augie Fackler <augie@google.com>
parents:
44352
diff
changeset
|
1253 raise FastdeltaUnavailable() |
948fac24bc39
manifest: introduce new exception to signal unavailability of fastdelta()
Augie Fackler <augie@google.com>
parents:
44352
diff
changeset
|
1254 |
31255
959ebff3505a
manifest: add match argument to diff and filesnotin
Durham Goode <durham@fb.com>
parents:
31153
diff
changeset
|
1255 def diff(self, m2, match=None, clean=False): |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1256 '''Finds changes between the current manifest and m2. |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1257 |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1258 Args: |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1259 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
|
1260 clean: if true, include files unchanged between these manifests |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1261 with a None value in the returned dictionary. |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1262 |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1263 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
|
1264 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
|
1265 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
|
1266 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
|
1267 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
|
1268 string. |
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1269 ''' |
39517
8798be5f04fc
treemanifest: avoid unnecessary copies/processing when using alwaysmatcher
Kyle Lippincott <spectral@google.com>
parents:
39516
diff
changeset
|
1270 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
|
1271 m1 = self._matches(match) |
0bf3b5e80d30
manifest: move matches method to be outside the interface
Augie Fackler <augie@google.com>
parents:
44286
diff
changeset
|
1272 m2 = m2._matches(match) |
31255
959ebff3505a
manifest: add match argument to diff and filesnotin
Durham Goode <durham@fb.com>
parents:
31153
diff
changeset
|
1273 return m1.diff(m2, clean=clean) |
24404
96cccf1e3257
treemanifest: make diff() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24403
diff
changeset
|
1274 result = {} |
96cccf1e3257
treemanifest: make diff() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24403
diff
changeset
|
1275 emptytree = treemanifest() |
41153
2c3f69855ce8
manifest: convert a recursive function to iterative one using stacks
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
41038
diff
changeset
|
1276 |
2c3f69855ce8
manifest: convert a recursive function to iterative one using stacks
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
41038
diff
changeset
|
1277 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
|
1278 """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
|
1279 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
|
1280 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
|
1281 return |
25222
0de132d5328a
treemanifest: lazily load manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
25221
diff
changeset
|
1282 t1._load() |
0de132d5328a
treemanifest: lazily load manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
25221
diff
changeset
|
1283 t2._load() |
40038
906c95073ff7
treemanifests: extract _loaddifflazy from _diff, use in _filesnotin
spectral <spectral@google.com>
parents:
39987
diff
changeset
|
1284 self._loaddifflazy(t1, t2) |
39984
731961d972ba
treemanifests: remove _loadalllazy in _diff()
spectral <spectral@google.com>
parents:
39983
diff
changeset
|
1285 |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43089
diff
changeset
|
1286 for d, m1 in pycompat.iteritems(t1._dirs): |
24404
96cccf1e3257
treemanifest: make diff() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24403
diff
changeset
|
1287 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
|
1288 stack.append((m1, m2)) |
24404
96cccf1e3257
treemanifest: make diff() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24403
diff
changeset
|
1289 |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43089
diff
changeset
|
1290 for d, m2 in pycompat.iteritems(t2._dirs): |
24404
96cccf1e3257
treemanifest: make diff() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24403
diff
changeset
|
1291 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
|
1292 stack.append((emptytree, m2)) |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1293 |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43089
diff
changeset
|
1294 for fn, n1 in pycompat.iteritems(t1._files): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1295 fl1 = t1._flags.get(fn, b'') |
24404
96cccf1e3257
treemanifest: make diff() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24403
diff
changeset
|
1296 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
|
1297 fl2 = t2._flags.get(fn, b'') |
24404
96cccf1e3257
treemanifest: make diff() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24403
diff
changeset
|
1298 if n1 != n2 or fl1 != fl2: |
96cccf1e3257
treemanifest: make diff() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24403
diff
changeset
|
1299 result[t1._subpath(fn)] = ((n1, fl1), (n2, fl2)) |
96cccf1e3257
treemanifest: make diff() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24403
diff
changeset
|
1300 elif clean: |
96cccf1e3257
treemanifest: make diff() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24403
diff
changeset
|
1301 result[t1._subpath(fn)] = None |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1302 |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43089
diff
changeset
|
1303 for fn, n2 in pycompat.iteritems(t2._files): |
24404
96cccf1e3257
treemanifest: make diff() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24403
diff
changeset
|
1304 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
|
1305 fl2 = t2._flags.get(fn, b'') |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1306 result[t2._subpath(fn)] = ((None, b''), (n2, fl2)) |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1307 |
41153
2c3f69855ce8
manifest: convert a recursive function to iterative one using stacks
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
41038
diff
changeset
|
1308 stackls = [] |
2c3f69855ce8
manifest: convert a recursive function to iterative one using stacks
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
41038
diff
changeset
|
1309 _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
|
1310 while stackls: |
2c3f69855ce8
manifest: convert a recursive function to iterative one using stacks
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
41038
diff
changeset
|
1311 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
|
1312 # 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
|
1313 _iterativediff(t1, t2, stackls) |
24404
96cccf1e3257
treemanifest: make diff() faster
Martin von Zweigbergk <martinvonz@google.com>
parents:
24403
diff
changeset
|
1314 return result |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1315 |
25221
eafa06e9edde
treemanifest: speed up commit using dirty flag
Martin von Zweigbergk <martinvonz@google.com>
parents:
25220
diff
changeset
|
1316 def unmodifiedsince(self, m2): |
eafa06e9edde
treemanifest: speed up commit using dirty flag
Martin von Zweigbergk <martinvonz@google.com>
parents:
25220
diff
changeset
|
1317 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
|
1318 |
25091
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
1319 def parse(self, text, readsubtree): |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
1320 selflazy = self._lazydirs |
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
1321 subpath = self._subpath |
24781
055b3cbe6c57
treemanifest: extract parse method from constructor
Martin von Zweigbergk <martinvonz@google.com>
parents:
24780
diff
changeset
|
1322 for f, n, fl in _parse(text): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1323 if fl == b't': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1324 f = f + b'/' |
40039
a0c18b271ea1
treemanifests: store whether a lazydirs entry needs copied after materializing
spectral <spectral@google.com>
parents:
40038
diff
changeset
|
1325 # 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
|
1326 # cached value from readsubtree directly. |
a0c18b271ea1
treemanifests: store whether a lazydirs entry needs copied after materializing
spectral <spectral@google.com>
parents:
40038
diff
changeset
|
1327 selflazy[f] = (subpath(f), n, readsubtree, False) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1328 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
|
1329 # 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
|
1330 # 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
|
1331 # 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
|
1332 # to nullid). |
25091
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
1333 self[f] = n |
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
1334 if fl: |
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
1335 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
|
1336 else: |
f0fbd88b21fb
treemanifest: speed up diff by keeping track of dirty nodes
Martin von Zweigbergk <martinvonz@google.com>
parents:
25188
diff
changeset
|
1337 # 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
|
1338 # 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
|
1339 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
|
1340 if fl: |
f0fbd88b21fb
treemanifest: speed up diff by keeping track of dirty nodes
Martin von Zweigbergk <martinvonz@google.com>
parents:
25188
diff
changeset
|
1341 self._flags[f] = fl |
24781
055b3cbe6c57
treemanifest: extract parse method from constructor
Martin von Zweigbergk <martinvonz@google.com>
parents:
24780
diff
changeset
|
1342 |
36373
0147a4730420
cleanup: say goodbye to manifestv2 format
Augie Fackler <augie@google.com>
parents:
36301
diff
changeset
|
1343 def text(self): |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1344 """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
|
1345 self._load() |
36373
0147a4730420
cleanup: say goodbye to manifestv2 format
Augie Fackler <augie@google.com>
parents:
36301
diff
changeset
|
1346 return _text(self.iterentries()) |
24401
e6e023d57e94
treemanifest: create treemanifest class
Martin von Zweigbergk <martinvonz@google.com>
parents:
24396
diff
changeset
|
1347 |
36373
0147a4730420
cleanup: say goodbye to manifestv2 format
Augie Fackler <augie@google.com>
parents:
36301
diff
changeset
|
1348 def dirtext(self): |
25091
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
1349 """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
|
1350 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
|
1351 """ |
25222
0de132d5328a
treemanifest: lazily load manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
25221
diff
changeset
|
1352 self._load() |
25091
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
1353 flags = self.flags |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43089
diff
changeset
|
1354 lazydirs = [ |
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43089
diff
changeset
|
1355 (d[:-1], v[1], b't') for d, v in pycompat.iteritems(self._lazydirs) |
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43089
diff
changeset
|
1356 ] |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1357 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
|
1358 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
|
1359 return _text(sorted(dirs + files + lazydirs)) |
25091
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
1360 |
25222
0de132d5328a
treemanifest: lazily load manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
25221
diff
changeset
|
1361 def read(self, gettext, readsubtree): |
26402
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1362 def _load_for_read(s): |
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1363 s.parse(gettext(), readsubtree) |
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1364 s._dirty = False |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1365 |
26402
05871262acd5
treemanifest: rework lazy-copying code (issue4840)
Augie Fackler <augie@google.com>
parents:
26401
diff
changeset
|
1366 self._loadfunc = _load_for_read |
25222
0de132d5328a
treemanifest: lazily load manifests
Martin von Zweigbergk <martinvonz@google.com>
parents:
25221
diff
changeset
|
1367 |
39668
24870f1be088
narrow: when writing treemanifests, skip inspecting directories outside narrow
spectral <spectral@google.com>
parents:
39522
diff
changeset
|
1368 def writesubtrees(self, m1, m2, writesubtree, match): |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1369 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
|
1370 m1._load() |
8a84347b9907
manifest: call m1.load and m2.load before writing a subtree
Durham Goode <durham@fb.com>
parents:
29826
diff
changeset
|
1371 m2._load() |
25091
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
1372 emptytree = treemanifest() |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1373 |
39518
c29548ba4a75
treemanifest: avoid loading everything just to get their nodeid
Kyle Lippincott <spectral@google.com>
parents:
39517
diff
changeset
|
1374 def getnode(m, d): |
c29548ba4a75
treemanifest: avoid loading everything just to get their nodeid
Kyle Lippincott <spectral@google.com>
parents:
39517
diff
changeset
|
1375 ld = m._lazydirs.get(d) |
c29548ba4a75
treemanifest: avoid loading everything just to get their nodeid
Kyle Lippincott <spectral@google.com>
parents:
39517
diff
changeset
|
1376 if ld: |
c29548ba4a75
treemanifest: avoid loading everything just to get their nodeid
Kyle Lippincott <spectral@google.com>
parents:
39517
diff
changeset
|
1377 return ld[1] |
c29548ba4a75
treemanifest: avoid loading everything just to get their nodeid
Kyle Lippincott <spectral@google.com>
parents:
39517
diff
changeset
|
1378 return m._dirs.get(d, emptytree)._node |
c29548ba4a75
treemanifest: avoid loading everything just to get their nodeid
Kyle Lippincott <spectral@google.com>
parents:
39517
diff
changeset
|
1379 |
39668
24870f1be088
narrow: when writing treemanifests, skip inspecting directories outside narrow
spectral <spectral@google.com>
parents:
39522
diff
changeset
|
1380 # 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
|
1381 visit = match.visitchildrenset(self._dir[:-1]) |
40040
67b93cd847fb
treemanifests: remove _loadalllazy when doing copies
spectral <spectral@google.com>
parents:
40039
diff
changeset
|
1382 visit = self._loadchildrensetlazy(visit) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1383 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
|
1384 visit = None |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43089
diff
changeset
|
1385 for d, subm in pycompat.iteritems(self._dirs): |
39668
24870f1be088
narrow: when writing treemanifests, skip inspecting directories outside narrow
spectral <spectral@google.com>
parents:
39522
diff
changeset
|
1386 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
|
1387 continue |
39518
c29548ba4a75
treemanifest: avoid loading everything just to get their nodeid
Kyle Lippincott <spectral@google.com>
parents:
39517
diff
changeset
|
1388 subp1 = getnode(m1, d) |
c29548ba4a75
treemanifest: avoid loading everything just to get their nodeid
Kyle Lippincott <spectral@google.com>
parents:
39517
diff
changeset
|
1389 subp2 = getnode(m2, d) |
39316
53363a8eff57
manifest: don't go through revlog to access node symbols
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39315
diff
changeset
|
1390 if subp1 == nullid: |
25091
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
1391 subp1, subp2 = subp2, subp1 |
39668
24870f1be088
narrow: when writing treemanifests, skip inspecting directories outside narrow
spectral <spectral@google.com>
parents:
39522
diff
changeset
|
1392 writesubtree(subm, subp1, subp2, match) |
25091
b5052fc73300
treemanifest: store submanifest revlog per directory
Martin von Zweigbergk <martinvonz@google.com>
parents:
24956
diff
changeset
|
1393 |
31876
94c1d3c1aea2
treemanifest: add walksubtrees api
Durham Goode <durham@fb.com>
parents:
31787
diff
changeset
|
1394 def walksubtrees(self, matcher=None): |
94c1d3c1aea2
treemanifest: add walksubtrees api
Durham Goode <durham@fb.com>
parents:
31787
diff
changeset
|
1395 """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
|
1396 manifest itself. |
94c1d3c1aea2
treemanifest: add walksubtrees api
Durham Goode <durham@fb.com>
parents:
31787
diff
changeset
|
1397 |
94c1d3c1aea2
treemanifest: add walksubtrees api
Durham Goode <durham@fb.com>
parents:
31787
diff
changeset
|
1398 If `matcher` is provided, it only returns subtrees that match. |
94c1d3c1aea2
treemanifest: add walksubtrees api
Durham Goode <durham@fb.com>
parents:
31787
diff
changeset
|
1399 """ |
42341
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41965
diff
changeset
|
1400 if matcher and not matcher.visitdir(self._dir[:-1]): |
31876
94c1d3c1aea2
treemanifest: add walksubtrees api
Durham Goode <durham@fb.com>
parents:
31787
diff
changeset
|
1401 return |
94c1d3c1aea2
treemanifest: add walksubtrees api
Durham Goode <durham@fb.com>
parents:
31787
diff
changeset
|
1402 if not matcher or matcher(self._dir[:-1]): |
94c1d3c1aea2
treemanifest: add walksubtrees api
Durham Goode <durham@fb.com>
parents:
31787
diff
changeset
|
1403 yield self |
94c1d3c1aea2
treemanifest: add walksubtrees api
Durham Goode <durham@fb.com>
parents:
31787
diff
changeset
|
1404 |
94c1d3c1aea2
treemanifest: add walksubtrees api
Durham Goode <durham@fb.com>
parents:
31787
diff
changeset
|
1405 self._load() |
39515
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
1406 # OPT: use visitchildrenset to avoid loading everything. |
93486cc46125
treemanifest: introduce lazy loading of subdirs
spectral <spectral@google.com>
parents:
39322
diff
changeset
|
1407 self._loadalllazy() |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43089
diff
changeset
|
1408 for d, subm in pycompat.iteritems(self._dirs): |
31876
94c1d3c1aea2
treemanifest: add walksubtrees api
Durham Goode <durham@fb.com>
parents:
31787
diff
changeset
|
1409 for subtree in subm.walksubtrees(matcher=matcher): |
94c1d3c1aea2
treemanifest: add walksubtrees api
Durham Goode <durham@fb.com>
parents:
31787
diff
changeset
|
1410 yield subtree |
94c1d3c1aea2
treemanifest: add walksubtrees api
Durham Goode <durham@fb.com>
parents:
31787
diff
changeset
|
1411 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1412 |
38781
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1413 class manifestfulltextcache(util.lrucachedict): |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1414 """File-backed LRU cache for the manifest cache |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1415 |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1416 File consists of entries, up to EOF: |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1417 |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1418 - 20 bytes node, 4 bytes length, <length> manifest data |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1419 |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1420 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
|
1421 |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1422 """ |
41962
07c80298b5a1
manifestcache: abstract the filename in a class attribute
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
41961
diff
changeset
|
1423 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1424 _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
|
1425 |
38781
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1426 def __init__(self, max): |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1427 super(manifestfulltextcache, self).__init__(max) |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1428 self._dirty = False |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1429 self._read = False |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1430 self._opener = None |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1431 |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1432 def read(self): |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1433 if self._read or self._opener is None: |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1434 return |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1435 |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1436 try: |
41962
07c80298b5a1
manifestcache: abstract the filename in a class attribute
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
41961
diff
changeset
|
1437 with self._opener(self._file) as fp: |
38781
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1438 set = super(manifestfulltextcache, self).__setitem__ |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1439 # 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
|
1440 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
|
1441 # 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
|
1442 node = fp.read(20) |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1443 if len(node) < 20: |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1444 break |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1445 try: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1446 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
|
1447 except struct.error: |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1448 break |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1449 value = bytearray(fp.read(size)) |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1450 if len(value) != size: |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1451 break |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1452 set(node, value) |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1453 except IOError: |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1454 # the file is allowed to be missing |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1455 pass |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1456 |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1457 self._read = True |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1458 self._dirty = False |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1459 |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1460 def write(self): |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1461 if not self._dirty or self._opener is None: |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1462 return |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1463 # 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
|
1464 try: |
35bb67427f63
manifest-cache: ignore IOError while writing
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44708
diff
changeset
|
1465 with self._opener( |
35bb67427f63
manifest-cache: ignore IOError while writing
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44708
diff
changeset
|
1466 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
|
1467 ) as fp: |
35bb67427f63
manifest-cache: ignore IOError while writing
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44708
diff
changeset
|
1468 node = self._head.prev |
35bb67427f63
manifest-cache: ignore IOError while writing
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44708
diff
changeset
|
1469 while True: |
35bb67427f63
manifest-cache: ignore IOError while writing
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44708
diff
changeset
|
1470 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
|
1471 fp.write(node.key) |
35bb67427f63
manifest-cache: ignore IOError while writing
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44708
diff
changeset
|
1472 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
|
1473 fp.write(node.value) |
35bb67427f63
manifest-cache: ignore IOError while writing
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44708
diff
changeset
|
1474 if node is self._head: |
35bb67427f63
manifest-cache: ignore IOError while writing
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44708
diff
changeset
|
1475 break |
35bb67427f63
manifest-cache: ignore IOError while writing
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44708
diff
changeset
|
1476 node = node.prev |
35bb67427f63
manifest-cache: ignore IOError while writing
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44708
diff
changeset
|
1477 except IOError: |
35bb67427f63
manifest-cache: ignore IOError while writing
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44708
diff
changeset
|
1478 # 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
|
1479 # the content can be missing. |
35bb67427f63
manifest-cache: ignore IOError while writing
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44708
diff
changeset
|
1480 # |
35bb67427f63
manifest-cache: ignore IOError while writing
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44708
diff
changeset
|
1481 # 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
|
1482 # 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
|
1483 # |
35bb67427f63
manifest-cache: ignore IOError while writing
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44708
diff
changeset
|
1484 # 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
|
1485 # 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
|
1486 pass |
38781
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1487 |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1488 def __len__(self): |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1489 if not self._read: |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1490 self.read() |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1491 return super(manifestfulltextcache, self).__len__() |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1492 |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1493 def __contains__(self, k): |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1494 if not self._read: |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1495 self.read() |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1496 return super(manifestfulltextcache, self).__contains__(k) |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1497 |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1498 def __iter__(self): |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1499 if not self._read: |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1500 self.read() |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1501 return super(manifestfulltextcache, self).__iter__() |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1502 |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1503 def __getitem__(self, k): |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1504 if not self._read: |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1505 self.read() |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1506 # the cache lru order can change on read |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1507 setdirty = self._cache.get(k) is not self._head |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1508 value = super(manifestfulltextcache, self).__getitem__(k) |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1509 if setdirty: |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1510 self._dirty = True |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1511 return value |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1512 |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1513 def __setitem__(self, k, v): |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1514 if not self._read: |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1515 self.read() |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1516 super(manifestfulltextcache, self).__setitem__(k, v) |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1517 self._dirty = True |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1518 |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1519 def __delitem__(self, k): |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1520 if not self._read: |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1521 self.read() |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1522 super(manifestfulltextcache, self).__delitem__(k) |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1523 self._dirty = True |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1524 |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1525 def get(self, k, default=None): |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1526 if not self._read: |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1527 self.read() |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1528 return super(manifestfulltextcache, self).get(k, default=default) |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1529 |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1530 def clear(self, clear_persisted_data=False): |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1531 super(manifestfulltextcache, self).clear() |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1532 if clear_persisted_data: |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1533 self._dirty = True |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1534 self.write() |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1535 self._read = False |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1536 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1537 |
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
|
1538 # 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
|
1539 # (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
|
1540 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
|
1541 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1542 |
44663
948fac24bc39
manifest: introduce new exception to signal unavailability of fastdelta()
Augie Fackler <augie@google.com>
parents:
44352
diff
changeset
|
1543 class FastdeltaUnavailable(Exception): |
948fac24bc39
manifest: introduce new exception to signal unavailability of fastdelta()
Augie Fackler <augie@google.com>
parents:
44352
diff
changeset
|
1544 """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
|
1545 |
948fac24bc39
manifest: introduce new exception to signal unavailability of fastdelta()
Augie Fackler <augie@google.com>
parents:
44352
diff
changeset
|
1546 |
39314
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1547 @interfaceutil.implementer(repository.imanifeststorage) |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1548 class manifestrevlog(object): |
29824
58d4ecdc531e
manifest: make manifest derive from manifestrevlog
Durham Goode <durham@fb.com>
parents:
29823
diff
changeset
|
1549 '''A revlog that stores manifest texts. This is responsible for caching the |
58d4ecdc531e
manifest: make manifest derive from manifestrevlog
Durham Goode <durham@fb.com>
parents:
29823
diff
changeset
|
1550 full-text manifest contents. |
58d4ecdc531e
manifest: make manifest derive from manifestrevlog
Durham Goode <durham@fb.com>
parents:
29823
diff
changeset
|
1551 ''' |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1552 |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1553 def __init__( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1554 self, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1555 opener, |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1556 tree=b'', |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1557 dirlogcache=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1558 indexfile=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1559 treemanifest=False, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1560 ): |
31151
6d9f8bc2b5ea
manifest: allow specifying the revlog filename
Durham Goode <durham@fb.com>
parents:
31097
diff
changeset
|
1561 """Constructs a new manifest revlog |
6d9f8bc2b5ea
manifest: allow specifying the revlog filename
Durham Goode <durham@fb.com>
parents:
31097
diff
changeset
|
1562 |
6d9f8bc2b5ea
manifest: allow specifying the revlog filename
Durham Goode <durham@fb.com>
parents:
31097
diff
changeset
|
1563 `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
|
1564 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
|
1565 |
d67991c4fefe
treemanifest: allow manifestrevlog to take an explicit treemanifest arg
Durham Goode <durham@fb.com>
parents:
32195
diff
changeset
|
1566 `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
|
1567 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
|
1568 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
|
1569 value is passed in to the constructor. |
31151
6d9f8bc2b5ea
manifest: allow specifying the revlog filename
Durham Goode <durham@fb.com>
parents:
31097
diff
changeset
|
1570 """ |
29824
58d4ecdc531e
manifest: make manifest derive from manifestrevlog
Durham Goode <durham@fb.com>
parents:
29823
diff
changeset
|
1571 # 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
|
1572 # 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
|
1573 # 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
|
1574 cachesize = 4 |
32252
d67991c4fefe
treemanifest: allow manifestrevlog to take an explicit treemanifest arg
Durham Goode <durham@fb.com>
parents:
32195
diff
changeset
|
1575 optiontreemanifest = False |
29824
58d4ecdc531e
manifest: make manifest derive from manifestrevlog
Durham Goode <durham@fb.com>
parents:
29823
diff
changeset
|
1576 opts = getattr(opener, 'options', None) |
58d4ecdc531e
manifest: make manifest derive from manifestrevlog
Durham Goode <durham@fb.com>
parents:
29823
diff
changeset
|
1577 if opts is not None: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1578 cachesize = opts.get(b'manifestcachesize', cachesize) |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1579 optiontreemanifest = opts.get(b'treemanifest', False) |
29940
fa145a205a7f
manifest: move revlog specific options from manifest to manifestrevlog
Durham Goode <durham@fb.com>
parents:
29939
diff
changeset
|
1580 |
32252
d67991c4fefe
treemanifest: allow manifestrevlog to take an explicit treemanifest arg
Durham Goode <durham@fb.com>
parents:
32195
diff
changeset
|
1581 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
|
1582 |
38781
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1583 self._fulltextcache = manifestfulltextcache(cachesize) |
29824
58d4ecdc531e
manifest: make manifest derive from manifestrevlog
Durham Goode <durham@fb.com>
parents:
29823
diff
changeset
|
1584 |
39243
0d97530eb535
manifest: rename dir argument and attribute to tree
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39242
diff
changeset
|
1585 if tree: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1586 assert self._treeondisk, b'opts is %r' % opts |
31151
6d9f8bc2b5ea
manifest: allow specifying the revlog filename
Durham Goode <durham@fb.com>
parents:
31097
diff
changeset
|
1587 |
6d9f8bc2b5ea
manifest: allow specifying the revlog filename
Durham Goode <durham@fb.com>
parents:
31097
diff
changeset
|
1588 if indexfile is None: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1589 indexfile = b'00manifest.i' |
39243
0d97530eb535
manifest: rename dir argument and attribute to tree
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39242
diff
changeset
|
1590 if tree: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1591 indexfile = b"meta/" + tree + indexfile |
31151
6d9f8bc2b5ea
manifest: allow specifying the revlog filename
Durham Goode <durham@fb.com>
parents:
31097
diff
changeset
|
1592 |
39315
57c3864f3aad
manifest: make tree a public attribute
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39314
diff
changeset
|
1593 self.tree = tree |
57c3864f3aad
manifest: make tree a public attribute
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39314
diff
changeset
|
1594 |
29941
1cc93a154723
manifest: move dirlog up to manifestrevlog
Durham Goode <durham@fb.com>
parents:
29940
diff
changeset
|
1595 # 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
|
1596 if tree: |
29941
1cc93a154723
manifest: move dirlog up to manifestrevlog
Durham Goode <durham@fb.com>
parents:
29940
diff
changeset
|
1597 self._dirlogcache = dirlogcache |
1cc93a154723
manifest: move dirlog up to manifestrevlog
Durham Goode <durham@fb.com>
parents:
29940
diff
changeset
|
1598 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1599 self._dirlogcache = {b'': self} |
29940
fa145a205a7f
manifest: move revlog specific options from manifest to manifestrevlog
Durham Goode <durham@fb.com>
parents:
29939
diff
changeset
|
1600 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1601 self._revlog = revlog.revlog( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1602 opener, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1603 indexfile, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1604 # only root indexfile is cached |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1605 checkambig=not bool(tree), |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1606 mmaplargeindex=True, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1607 upperboundcomp=MAXCOMPRESSION, |
44792
5e3c718692bb
nodemap: drop the 'exp-' prefix for internal opener option
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44787
diff
changeset
|
1608 persistentnodemap=opener.options.get(b'persistent-nodemap', False), |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1609 ) |
39314
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1610 |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1611 self.index = self._revlog.index |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1612 self.version = self._revlog.version |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1613 self._generaldelta = self._revlog._generaldelta |
29940
fa145a205a7f
manifest: move revlog specific options from manifest to manifestrevlog
Durham Goode <durham@fb.com>
parents:
29939
diff
changeset
|
1614 |
38781
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1615 def _setupmanifestcachehooks(self, repo): |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1616 """Persist the manifestfulltextcache on lock release""" |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1617 if not util.safehasattr(repo, b'_wlockref'): |
38781
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1618 return |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1619 |
41965
e4ac7e63c213
manifestcache: use `wcache` directory for manifest cache
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
41964
diff
changeset
|
1620 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
|
1621 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
|
1622 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
|
1623 |
38781
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1624 reporef = weakref.ref(repo) |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1625 manifestrevlogref = weakref.ref(self) |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1626 |
43778
888bd39ed555
lock: pass "success" boolean to _afterlock callbacks
Kyle Lippincott <spectral@google.com>
parents:
43523
diff
changeset
|
1627 def persistmanifestcache(success): |
888bd39ed555
lock: pass "success" boolean to _afterlock callbacks
Kyle Lippincott <spectral@google.com>
parents:
43523
diff
changeset
|
1628 # 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
|
1629 if not success: |
888bd39ed555
lock: pass "success" boolean to _afterlock callbacks
Kyle Lippincott <spectral@google.com>
parents:
43523
diff
changeset
|
1630 return |
888bd39ed555
lock: pass "success" boolean to _afterlock callbacks
Kyle Lippincott <spectral@google.com>
parents:
43523
diff
changeset
|
1631 |
38781
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1632 repo = reporef() |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1633 self = manifestrevlogref() |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1634 if repo is None or self is None: |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1635 return |
39320
57301ba47e66
manifest: use public API for obtaining storage object
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39317
diff
changeset
|
1636 if repo.manifestlog.getstorage(b'') is not self: |
38781
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1637 # there's a different manifest in play now, abort |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1638 return |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1639 self._fulltextcache.write() |
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1640 |
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
|
1641 repo._afterlock(persistmanifestcache) |
38781
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1642 |
29824
58d4ecdc531e
manifest: make manifest derive from manifestrevlog
Durham Goode <durham@fb.com>
parents:
29823
diff
changeset
|
1643 @property |
58d4ecdc531e
manifest: make manifest derive from manifestrevlog
Durham Goode <durham@fb.com>
parents:
29823
diff
changeset
|
1644 def fulltextcache(self): |
58d4ecdc531e
manifest: make manifest derive from manifestrevlog
Durham Goode <durham@fb.com>
parents:
29823
diff
changeset
|
1645 return self._fulltextcache |
58d4ecdc531e
manifest: make manifest derive from manifestrevlog
Durham Goode <durham@fb.com>
parents:
29823
diff
changeset
|
1646 |
38781
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1647 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
|
1648 self._revlog.clearcaches() |
38781
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1649 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
|
1650 self._dirlogcache = {self.tree: self} |
29941
1cc93a154723
manifest: move dirlog up to manifestrevlog
Durham Goode <durham@fb.com>
parents:
29940
diff
changeset
|
1651 |
36095
59adb3051718
manifest: clean up dirlog() to take a d parameter to avoid shadowing dir()
Augie Fackler <augie@google.com>
parents:
35586
diff
changeset
|
1652 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
|
1653 if d: |
29941
1cc93a154723
manifest: move dirlog up to manifestrevlog
Durham Goode <durham@fb.com>
parents:
29940
diff
changeset
|
1654 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
|
1655 if d not in self._dirlogcache: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1656 mfrevlog = manifestrevlog( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1657 self.opener, d, self._dirlogcache, treemanifest=self._treeondisk |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1658 ) |
36095
59adb3051718
manifest: clean up dirlog() to take a d parameter to avoid shadowing dir()
Augie Fackler <augie@google.com>
parents:
35586
diff
changeset
|
1659 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
|
1660 return self._dirlogcache[d] |
29824
58d4ecdc531e
manifest: make manifest derive from manifestrevlog
Durham Goode <durham@fb.com>
parents:
29823
diff
changeset
|
1661 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1662 def add( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1663 self, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1664 m, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1665 transaction, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1666 link, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1667 p1, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1668 p2, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1669 added, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1670 removed, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1671 readtree=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1672 match=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1673 ): |
45066
5a80915e99ce
commitctx: document the manifest writing function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44852
diff
changeset
|
1674 """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
|
1675 |
5a80915e99ce
commitctx: document the manifest writing function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44852
diff
changeset
|
1676 input: |
5a80915e99ce
commitctx: document the manifest writing function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44852
diff
changeset
|
1677 |
5a80915e99ce
commitctx: document the manifest writing function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44852
diff
changeset
|
1678 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
|
1679 transaction: the open transaction |
5a80915e99ce
commitctx: document the manifest writing function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44852
diff
changeset
|
1680 p1: manifest-node of p1 |
5a80915e99ce
commitctx: document the manifest writing function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44852
diff
changeset
|
1681 p2: manifest-node of p2 |
5a80915e99ce
commitctx: document the manifest writing function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44852
diff
changeset
|
1682 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
|
1683 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
|
1684 |
5a80915e99ce
commitctx: document the manifest writing function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44852
diff
changeset
|
1685 tree manifest input: |
5a80915e99ce
commitctx: document the manifest writing function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44852
diff
changeset
|
1686 |
5a80915e99ce
commitctx: document the manifest writing function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44852
diff
changeset
|
1687 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
|
1688 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
|
1689 """ |
44663
948fac24bc39
manifest: introduce new exception to signal unavailability of fastdelta()
Augie Fackler <augie@google.com>
parents:
44352
diff
changeset
|
1690 try: |
948fac24bc39
manifest: introduce new exception to signal unavailability of fastdelta()
Augie Fackler <augie@google.com>
parents:
44352
diff
changeset
|
1691 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
|
1692 raise FastdeltaUnavailable() |
29961
774a15b129e8
manifest: move manifest.add onto manifestrevlog
Durham Goode <durham@fb.com>
parents:
29960
diff
changeset
|
1693 # 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
|
1694 # 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
|
1695 # 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
|
1696 # revlog layer. |
774a15b129e8
manifest: move manifest.add onto manifestrevlog
Durham Goode <durham@fb.com>
parents:
29960
diff
changeset
|
1697 |
774a15b129e8
manifest: move manifest.add onto manifestrevlog
Durham Goode <durham@fb.com>
parents:
29960
diff
changeset
|
1698 _checkforbidden(added) |
774a15b129e8
manifest: move manifest.add onto manifestrevlog
Durham Goode <durham@fb.com>
parents:
29960
diff
changeset
|
1699 # combine the changed lists into one sorted iterator |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1700 work = heapq.merge( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1701 [(x, False) for x in sorted(added)], |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1702 [(x, True) for x in sorted(removed)], |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1703 ) |
29961
774a15b129e8
manifest: move manifest.add onto manifestrevlog
Durham Goode <durham@fb.com>
parents:
29960
diff
changeset
|
1704 |
774a15b129e8
manifest: move manifest.add onto manifestrevlog
Durham Goode <durham@fb.com>
parents:
29960
diff
changeset
|
1705 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
|
1706 cachedelta = self._revlog.rev(p1), deltatext |
29961
774a15b129e8
manifest: move manifest.add onto manifestrevlog
Durham Goode <durham@fb.com>
parents:
29960
diff
changeset
|
1707 text = util.buffer(arraytext) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1708 n = self._revlog.addrevision( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1709 text, transaction, link, p1, p2, cachedelta |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1710 ) |
44663
948fac24bc39
manifest: introduce new exception to signal unavailability of fastdelta()
Augie Fackler <augie@google.com>
parents:
44352
diff
changeset
|
1711 except FastdeltaUnavailable: |
948fac24bc39
manifest: introduce new exception to signal unavailability of fastdelta()
Augie Fackler <augie@google.com>
parents:
44352
diff
changeset
|
1712 # 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
|
1713 # 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
|
1714 # 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
|
1715 # 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
|
1716 # delta process. |
29961
774a15b129e8
manifest: move manifest.add onto manifestrevlog
Durham Goode <durham@fb.com>
parents:
29960
diff
changeset
|
1717 if self._treeondisk: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1718 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
|
1719 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
|
1720 m1 = readtree(self.tree, p1) |
57c3864f3aad
manifest: make tree a public attribute
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39314
diff
changeset
|
1721 m2 = readtree(self.tree, p2) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1722 n = self._addtree( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1723 m, transaction, link, m1, m2, readtree, match=match |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1724 ) |
29961
774a15b129e8
manifest: move manifest.add onto manifestrevlog
Durham Goode <durham@fb.com>
parents:
29960
diff
changeset
|
1725 arraytext = None |
774a15b129e8
manifest: move manifest.add onto manifestrevlog
Durham Goode <durham@fb.com>
parents:
29960
diff
changeset
|
1726 else: |
36373
0147a4730420
cleanup: say goodbye to manifestv2 format
Augie Fackler <augie@google.com>
parents:
36301
diff
changeset
|
1727 text = m.text() |
39314
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1728 n = self._revlog.addrevision(text, transaction, link, p1, p2) |
31346
2a18e9e6ca43
py3: use bytearray() instead of array('c', ...) constructions
Augie Fackler <augie@google.com>
parents:
31294
diff
changeset
|
1729 arraytext = bytearray(text) |
29961
774a15b129e8
manifest: move manifest.add onto manifestrevlog
Durham Goode <durham@fb.com>
parents:
29960
diff
changeset
|
1730 |
30209
9d06b65c5df2
manifest: don't store None in fulltextcache
Martin von Zweigbergk <martinvonz@google.com>
parents:
30207
diff
changeset
|
1731 if arraytext is not None: |
9d06b65c5df2
manifest: don't store None in fulltextcache
Martin von Zweigbergk <martinvonz@google.com>
parents:
30207
diff
changeset
|
1732 self.fulltextcache[n] = arraytext |
29961
774a15b129e8
manifest: move manifest.add onto manifestrevlog
Durham Goode <durham@fb.com>
parents:
29960
diff
changeset
|
1733 |
774a15b129e8
manifest: move manifest.add onto manifestrevlog
Durham Goode <durham@fb.com>
parents:
29960
diff
changeset
|
1734 return n |
774a15b129e8
manifest: move manifest.add onto manifestrevlog
Durham Goode <durham@fb.com>
parents:
29960
diff
changeset
|
1735 |
39668
24870f1be088
narrow: when writing treemanifests, skip inspecting directories outside narrow
spectral <spectral@google.com>
parents:
39522
diff
changeset
|
1736 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
|
1737 # 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
|
1738 # 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
|
1739 if self.tree != b'' and ( |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1740 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
|
1741 ): |
29961
774a15b129e8
manifest: move manifest.add onto manifestrevlog
Durham Goode <durham@fb.com>
parents:
29960
diff
changeset
|
1742 return m.node() |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1743 |
39668
24870f1be088
narrow: when writing treemanifests, skip inspecting directories outside narrow
spectral <spectral@google.com>
parents:
39522
diff
changeset
|
1744 def writesubtree(subm, subp1, subp2, match): |
29961
774a15b129e8
manifest: move manifest.add onto manifestrevlog
Durham Goode <durham@fb.com>
parents:
29960
diff
changeset
|
1745 sublog = self.dirlog(subm.dir()) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1746 sublog.add( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1747 subm, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1748 transaction, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1749 link, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1750 subp1, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1751 subp2, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1752 None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1753 None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1754 readtree=readtree, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1755 match=match, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1756 ) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1757 |
39668
24870f1be088
narrow: when writing treemanifests, skip inspecting directories outside narrow
spectral <spectral@google.com>
parents:
39522
diff
changeset
|
1758 m.writesubtrees(m1, m2, writesubtree, match) |
36373
0147a4730420
cleanup: say goodbye to manifestv2 format
Augie Fackler <augie@google.com>
parents:
36301
diff
changeset
|
1759 text = m.dirtext() |
31294
c134a33b1d73
treemanifest: make node reuse match flat manifest behavior
Durham Goode <durham@fb.com>
parents:
31255
diff
changeset
|
1760 n = None |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1761 if self.tree != b'': |
31294
c134a33b1d73
treemanifest: make node reuse match flat manifest behavior
Durham Goode <durham@fb.com>
parents:
31255
diff
changeset
|
1762 # 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
|
1763 if text == m1.dirtext(): |
31294
c134a33b1d73
treemanifest: make node reuse match flat manifest behavior
Durham Goode <durham@fb.com>
parents:
31255
diff
changeset
|
1764 n = m1.node() |
36373
0147a4730420
cleanup: say goodbye to manifestv2 format
Augie Fackler <augie@google.com>
parents:
36301
diff
changeset
|
1765 elif text == m2.dirtext(): |
31294
c134a33b1d73
treemanifest: make node reuse match flat manifest behavior
Durham Goode <durham@fb.com>
parents:
31255
diff
changeset
|
1766 n = m2.node() |
c134a33b1d73
treemanifest: make node reuse match flat manifest behavior
Durham Goode <durham@fb.com>
parents:
31255
diff
changeset
|
1767 |
c134a33b1d73
treemanifest: make node reuse match flat manifest behavior
Durham Goode <durham@fb.com>
parents:
31255
diff
changeset
|
1768 if not n: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1769 n = self._revlog.addrevision( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1770 text, transaction, link, m1.node(), m2.node() |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1771 ) |
31294
c134a33b1d73
treemanifest: make node reuse match flat manifest behavior
Durham Goode <durham@fb.com>
parents:
31255
diff
changeset
|
1772 |
29961
774a15b129e8
manifest: move manifest.add onto manifestrevlog
Durham Goode <durham@fb.com>
parents:
29960
diff
changeset
|
1773 # 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
|
1774 m.setnode(n) |
774a15b129e8
manifest: move manifest.add onto manifestrevlog
Durham Goode <durham@fb.com>
parents:
29960
diff
changeset
|
1775 return n |
774a15b129e8
manifest: move manifest.add onto manifestrevlog
Durham Goode <durham@fb.com>
parents:
29960
diff
changeset
|
1776 |
39314
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1777 def __len__(self): |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1778 return len(self._revlog) |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1779 |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1780 def __iter__(self): |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1781 return self._revlog.__iter__() |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1782 |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1783 def rev(self, node): |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1784 return self._revlog.rev(node) |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1785 |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1786 def node(self, rev): |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1787 return self._revlog.node(rev) |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1788 |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1789 def lookup(self, value): |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1790 return self._revlog.lookup(value) |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1791 |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1792 def parentrevs(self, rev): |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1793 return self._revlog.parentrevs(rev) |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1794 |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1795 def parents(self, node): |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1796 return self._revlog.parents(node) |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1797 |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1798 def linkrev(self, rev): |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1799 return self._revlog.linkrev(rev) |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1800 |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1801 def checksize(self): |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1802 return self._revlog.checksize() |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1803 |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1804 def revision(self, node, _df=None, raw=False): |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1805 return self._revlog.revision(node, _df=_df, raw=raw) |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1806 |
42723
2128c76c8970
rawdata: forward `rawdata` call on `manifestlog`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42469
diff
changeset
|
1807 def rawdata(self, node, _df=None): |
2128c76c8970
rawdata: forward `rawdata` call on `manifestlog`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42469
diff
changeset
|
1808 return self._revlog.rawdata(node, _df=_df) |
2128c76c8970
rawdata: forward `rawdata` call on `manifestlog`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42469
diff
changeset
|
1809 |
39314
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1810 def revdiff(self, rev1, rev2): |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1811 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
|
1812 |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1813 def cmp(self, node, text): |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1814 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
|
1815 |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1816 def deltaparent(self, rev): |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1817 return self._revlog.deltaparent(rev) |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1818 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1819 def emitrevisions( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1820 self, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1821 nodes, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1822 nodesorder=None, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1823 revisiondata=False, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1824 assumehaveparentrevisions=False, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1825 deltamode=repository.CG_DELTAMODE_STD, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1826 ): |
39862
5a9ab91e0a45
revlog: new API to emit revision data
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39858
diff
changeset
|
1827 return self._revlog.emitrevisions( |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1828 nodes, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1829 nodesorder=nodesorder, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1830 revisiondata=revisiondata, |
39862
5a9ab91e0a45
revlog: new API to emit revision data
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39858
diff
changeset
|
1831 assumehaveparentrevisions=assumehaveparentrevisions, |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1832 deltamode=deltamode, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1833 ) |
39862
5a9ab91e0a45
revlog: new API to emit revision data
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39858
diff
changeset
|
1834 |
45788
a5206e71c536
revlog: extend addgroup() with callback for duplicates
Joerg Sonnenberger <joerg@bec.de>
parents:
45220
diff
changeset
|
1835 def addgroup( |
a5206e71c536
revlog: extend addgroup() with callback for duplicates
Joerg Sonnenberger <joerg@bec.de>
parents:
45220
diff
changeset
|
1836 self, |
a5206e71c536
revlog: extend addgroup() with callback for duplicates
Joerg Sonnenberger <joerg@bec.de>
parents:
45220
diff
changeset
|
1837 deltas, |
a5206e71c536
revlog: extend addgroup() with callback for duplicates
Joerg Sonnenberger <joerg@bec.de>
parents:
45220
diff
changeset
|
1838 linkmapper, |
a5206e71c536
revlog: extend addgroup() with callback for duplicates
Joerg Sonnenberger <joerg@bec.de>
parents:
45220
diff
changeset
|
1839 transaction, |
a5206e71c536
revlog: extend addgroup() with callback for duplicates
Joerg Sonnenberger <joerg@bec.de>
parents:
45220
diff
changeset
|
1840 addrevisioncb=None, |
a5206e71c536
revlog: extend addgroup() with callback for duplicates
Joerg Sonnenberger <joerg@bec.de>
parents:
45220
diff
changeset
|
1841 duplicaterevisioncb=None, |
a5206e71c536
revlog: extend addgroup() with callback for duplicates
Joerg Sonnenberger <joerg@bec.de>
parents:
45220
diff
changeset
|
1842 ): |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1843 return self._revlog.addgroup( |
45788
a5206e71c536
revlog: extend addgroup() with callback for duplicates
Joerg Sonnenberger <joerg@bec.de>
parents:
45220
diff
changeset
|
1844 deltas, |
a5206e71c536
revlog: extend addgroup() with callback for duplicates
Joerg Sonnenberger <joerg@bec.de>
parents:
45220
diff
changeset
|
1845 linkmapper, |
a5206e71c536
revlog: extend addgroup() with callback for duplicates
Joerg Sonnenberger <joerg@bec.de>
parents:
45220
diff
changeset
|
1846 transaction, |
a5206e71c536
revlog: extend addgroup() with callback for duplicates
Joerg Sonnenberger <joerg@bec.de>
parents:
45220
diff
changeset
|
1847 addrevisioncb=addrevisioncb, |
a5206e71c536
revlog: extend addgroup() with callback for duplicates
Joerg Sonnenberger <joerg@bec.de>
parents:
45220
diff
changeset
|
1848 duplicaterevisioncb=duplicaterevisioncb, |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1849 ) |
39314
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1850 |
39858
9534fe1e5d28
manifest: add rawsize() proxy (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39777
diff
changeset
|
1851 def rawsize(self, rev): |
9534fe1e5d28
manifest: add rawsize() proxy (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39777
diff
changeset
|
1852 return self._revlog.rawsize(rev) |
9534fe1e5d28
manifest: add rawsize() proxy (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39777
diff
changeset
|
1853 |
39314
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1854 def getstrippoint(self, minlink): |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1855 return self._revlog.getstrippoint(minlink) |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1856 |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1857 def strip(self, minlink, transaction): |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1858 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
|
1859 |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1860 def files(self): |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1861 return self._revlog.files() |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1862 |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1863 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
|
1864 if not isinstance(destrevlog, manifestrevlog): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1865 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
|
1866 |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1867 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
|
1868 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1869 def storageinfo( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1870 self, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1871 exclusivefiles=False, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1872 sharedfiles=False, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1873 revisionscount=False, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1874 trackedsize=False, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1875 storedsize=False, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1876 ): |
39869
14e500b58263
revlog: add method for obtaining storage info (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39866
diff
changeset
|
1877 return self._revlog.storageinfo( |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1878 exclusivefiles=exclusivefiles, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1879 sharedfiles=sharedfiles, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1880 revisionscount=revisionscount, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1881 trackedsize=trackedsize, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1882 storedsize=storedsize, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1883 ) |
39869
14e500b58263
revlog: add method for obtaining storage info (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39866
diff
changeset
|
1884 |
39314
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1885 @property |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1886 def indexfile(self): |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1887 return self._revlog.indexfile |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1888 |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1889 @indexfile.setter |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1890 def indexfile(self, value): |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1891 self._revlog.indexfile = value |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1892 |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1893 @property |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1894 def opener(self): |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1895 return self._revlog.opener |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1896 |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1897 @opener.setter |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1898 def opener(self, value): |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1899 self._revlog.opener = value |
7f5e6d3e9032
manifest: proxy to revlog instance instead of inheriting
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39246
diff
changeset
|
1900 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1901 |
38530
c82ea938efbb
repository: define manifest interfaces
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38510
diff
changeset
|
1902 @interfaceutil.implementer(repository.imanifestlog) |
29825
426d931e5db2
manifest: introduce manifestlog and manifestctx classes
Durham Goode <durham@fb.com>
parents:
29824
diff
changeset
|
1903 class manifestlog(object): |
426d931e5db2
manifest: introduce manifestlog and manifestctx classes
Durham Goode <durham@fb.com>
parents:
29824
diff
changeset
|
1904 """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
|
1905 referenced by commits in the repository. |
426d931e5db2
manifest: introduce manifestlog and manifestctx classes
Durham Goode <durham@fb.com>
parents:
29824
diff
changeset
|
1906 |
426d931e5db2
manifest: introduce manifestlog and manifestctx classes
Durham Goode <durham@fb.com>
parents:
29824
diff
changeset
|
1907 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
|
1908 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
|
1909 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
|
1910 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
|
1911 |
41038
3913223417ea
manifest: accept narrowmatch into constructor instead of getting from repo
Martin von Zweigbergk <martinvonz@google.com>
parents:
40430
diff
changeset
|
1912 def __init__(self, opener, repo, rootstore, narrowmatch): |
29959
483003c27938
manifest: move treeinmem onto manifestlog
Durham Goode <durham@fb.com>
parents:
29941
diff
changeset
|
1913 usetreemanifest = False |
30372
7c7d845f8b64
manifest: make manifestlog use it's own cache
Durham Goode <durham@fb.com>
parents:
30371
diff
changeset
|
1914 cachesize = 4 |
29959
483003c27938
manifest: move treeinmem onto manifestlog
Durham Goode <durham@fb.com>
parents:
29941
diff
changeset
|
1915 |
483003c27938
manifest: move treeinmem onto manifestlog
Durham Goode <durham@fb.com>
parents:
29941
diff
changeset
|
1916 opts = getattr(opener, 'options', None) |
483003c27938
manifest: move treeinmem onto manifestlog
Durham Goode <durham@fb.com>
parents:
29941
diff
changeset
|
1917 if opts is not None: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1918 usetreemanifest = opts.get(b'treemanifest', usetreemanifest) |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1919 cachesize = opts.get(b'manifestcachesize', cachesize) |
39245
071f97d03acb
manifest: rename manifestlog._treeinmem to ._treemanifests
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39244
diff
changeset
|
1920 |
071f97d03acb
manifest: rename manifestlog._treeinmem to ._treemanifests
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39244
diff
changeset
|
1921 self._treemanifests = usetreemanifest |
29959
483003c27938
manifest: move treeinmem onto manifestlog
Durham Goode <durham@fb.com>
parents:
29941
diff
changeset
|
1922 |
39763
5ccd791344f3
localrepo: pass root manifest into manifestlog.__init__
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39668
diff
changeset
|
1923 self._rootstore = rootstore |
39321
52860f52ed13
manifest: rename manifestlog._revlog to _rootstore
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39320
diff
changeset
|
1924 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
|
1925 self._narrowmatch = narrowmatch |
30219
3c8811efdddc
manifest: make manifestlog a storecache
Durham Goode <durham@fb.com>
parents:
30209
diff
changeset
|
1926 |
30292
d4b340bf68c5
manifest: change manifestlog mancache to be directory based
Durham Goode <durham@fb.com>
parents:
30291
diff
changeset
|
1927 # 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
|
1928 self._dirmancache = {} |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1929 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
|
1930 |
38510
561a450c7b64
manifest: make cachesize a private attribute
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38331
diff
changeset
|
1931 self._cachesize = cachesize |
29826
93b44aa17691
manifest: use property instead of field for manifest revlog storage
Durham Goode <durham@fb.com>
parents:
29825
diff
changeset
|
1932 |
29825
426d931e5db2
manifest: introduce manifestlog and manifestctx classes
Durham Goode <durham@fb.com>
parents:
29824
diff
changeset
|
1933 def __getitem__(self, node): |
30290
1a0c1ad57833
manifest: throw LookupError if node not in revlog
Durham Goode <durham@fb.com>
parents:
30221
diff
changeset
|
1934 """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
|
1935 LookupError if not found. |
29825
426d931e5db2
manifest: introduce manifestlog and manifestctx classes
Durham Goode <durham@fb.com>
parents:
29824
diff
changeset
|
1936 """ |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1937 return self.get(b'', node) |
29825
426d931e5db2
manifest: introduce manifestlog and manifestctx classes
Durham Goode <durham@fb.com>
parents:
29824
diff
changeset
|
1938 |
39235
43387fd2aa1f
manifest: rename dir to tree to avoid shadowing built-in
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38781
diff
changeset
|
1939 def get(self, tree, node, verify=True): |
30291
dc21ea3323c4
manifest: add manifestlog.get to obtain subdirectory instances
Durham Goode <durham@fb.com>
parents:
30290
diff
changeset
|
1940 """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
|
1941 LookupError if not found. |
30403
a431daa93f8c
manifest: make revlog verification optional
Durham Goode <durham@fb.com>
parents:
30377
diff
changeset
|
1942 |
a431daa93f8c
manifest: make revlog verification optional
Durham Goode <durham@fb.com>
parents:
30377
diff
changeset
|
1943 `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
|
1944 the revlog |
30291
dc21ea3323c4
manifest: add manifestlog.get to obtain subdirectory instances
Durham Goode <durham@fb.com>
parents:
30290
diff
changeset
|
1945 """ |
39235
43387fd2aa1f
manifest: rename dir to tree to avoid shadowing built-in
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38781
diff
changeset
|
1946 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
|
1947 return self._dirmancache[tree][node] |
30292
d4b340bf68c5
manifest: change manifestlog mancache to be directory based
Durham Goode <durham@fb.com>
parents:
30291
diff
changeset
|
1948 |
37374
ac42e39b1b77
narrow: move manifestlog overrides to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37373
diff
changeset
|
1949 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
|
1950 if not self._narrowmatch.visitdir(tree[:-1]): |
39235
43387fd2aa1f
manifest: rename dir to tree to avoid shadowing built-in
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38781
diff
changeset
|
1951 return excludeddirmanifestctx(tree, node) |
43387fd2aa1f
manifest: rename dir to tree to avoid shadowing built-in
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38781
diff
changeset
|
1952 if tree: |
39321
52860f52ed13
manifest: rename manifestlog._revlog to _rootstore
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39320
diff
changeset
|
1953 if self._rootstore._treeondisk: |
30403
a431daa93f8c
manifest: make revlog verification optional
Durham Goode <durham@fb.com>
parents:
30377
diff
changeset
|
1954 if verify: |
39246
61700d525a3b
manifest: use rev() instead of nodemap.__contains__
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39245
diff
changeset
|
1955 # 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
|
1956 # exist. |
61700d525a3b
manifest: use rev() instead of nodemap.__contains__
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39245
diff
changeset
|
1957 self.getstorage(tree).rev(node) |
61700d525a3b
manifest: use rev() instead of nodemap.__contains__
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39245
diff
changeset
|
1958 |
39235
43387fd2aa1f
manifest: rename dir to tree to avoid shadowing built-in
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38781
diff
changeset
|
1959 m = treemanifestctx(self, tree, node) |
30291
dc21ea3323c4
manifest: add manifestlog.get to obtain subdirectory instances
Durham Goode <durham@fb.com>
parents:
30290
diff
changeset
|
1960 else: |
dc21ea3323c4
manifest: add manifestlog.get to obtain subdirectory instances
Durham Goode <durham@fb.com>
parents:
30290
diff
changeset
|
1961 raise error.Abort( |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1962 _( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1963 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
|
1964 b"manifest" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1965 ) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1966 % tree |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1967 ) |
29907
4fb4fc331699
manifest: add treemanifestctx class
Durham Goode <durham@fb.com>
parents:
29888
diff
changeset
|
1968 else: |
30403
a431daa93f8c
manifest: make revlog verification optional
Durham Goode <durham@fb.com>
parents:
30377
diff
changeset
|
1969 if verify: |
39246
61700d525a3b
manifest: use rev() instead of nodemap.__contains__
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39245
diff
changeset
|
1970 # 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
|
1971 self._rootstore.rev(node) |
39246
61700d525a3b
manifest: use rev() instead of nodemap.__contains__
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39245
diff
changeset
|
1972 |
39245
071f97d03acb
manifest: rename manifestlog._treeinmem to ._treemanifests
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39244
diff
changeset
|
1973 if self._treemanifests: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1974 m = treemanifestctx(self, b'', node) |
30291
dc21ea3323c4
manifest: add manifestlog.get to obtain subdirectory instances
Durham Goode <durham@fb.com>
parents:
30290
diff
changeset
|
1975 else: |
31153
5cab44fd1257
manifest: remove _repo from manifestctx objects
Durham Goode <durham@fb.com>
parents:
31151
diff
changeset
|
1976 m = manifestctx(self, node) |
30292
d4b340bf68c5
manifest: change manifestlog mancache to be directory based
Durham Goode <durham@fb.com>
parents:
30291
diff
changeset
|
1977 |
39316
53363a8eff57
manifest: don't go through revlog to access node symbols
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39315
diff
changeset
|
1978 if node != nullid: |
39235
43387fd2aa1f
manifest: rename dir to tree to avoid shadowing built-in
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38781
diff
changeset
|
1979 mancache = self._dirmancache.get(tree) |
30292
d4b340bf68c5
manifest: change manifestlog mancache to be directory based
Durham Goode <durham@fb.com>
parents:
30291
diff
changeset
|
1980 if not mancache: |
38510
561a450c7b64
manifest: make cachesize a private attribute
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38331
diff
changeset
|
1981 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
|
1982 self._dirmancache[tree] = mancache |
30292
d4b340bf68c5
manifest: change manifestlog mancache to be directory based
Durham Goode <durham@fb.com>
parents:
30291
diff
changeset
|
1983 mancache[node] = m |
29825
426d931e5db2
manifest: introduce manifestlog and manifestctx classes
Durham Goode <durham@fb.com>
parents:
29824
diff
changeset
|
1984 return m |
426d931e5db2
manifest: introduce manifestlog and manifestctx classes
Durham Goode <durham@fb.com>
parents:
29824
diff
changeset
|
1985 |
39244
73cf21b2e8a6
manifest: add getstorage() to manifestlog and use it globally
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39243
diff
changeset
|
1986 def getstorage(self, tree): |
39321
52860f52ed13
manifest: rename manifestlog._revlog to _rootstore
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39320
diff
changeset
|
1987 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
|
1988 |
38781
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
1989 def clearcaches(self, clear_persisted_data=False): |
30370
10c924596e5c
manifest: move clearcaches to manifestlog
Durham Goode <durham@fb.com>
parents:
30369
diff
changeset
|
1990 self._dirmancache.clear() |
39321
52860f52ed13
manifest: rename manifestlog._revlog to _rootstore
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39320
diff
changeset
|
1991 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
|
1992 |
38555
f2f9bacf0587
manifest: define and implement rev() on manifestlog
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38530
diff
changeset
|
1993 def rev(self, node): |
39321
52860f52ed13
manifest: rename manifestlog._revlog to _rootstore
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39320
diff
changeset
|
1994 return self._rootstore.rev(node) |
38555
f2f9bacf0587
manifest: define and implement rev() on manifestlog
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38530
diff
changeset
|
1995 |
44787
97ebdb192b00
nodemap: also warm manifest nodemap with other caches
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44786
diff
changeset
|
1996 def update_caches(self, transaction): |
97ebdb192b00
nodemap: also warm manifest nodemap with other caches
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44786
diff
changeset
|
1997 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
|
1998 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
1999 |
38530
c82ea938efbb
repository: define manifest interfaces
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38510
diff
changeset
|
2000 @interfaceutil.implementer(repository.imanifestrevisionwritable) |
30342
fe1ee393de78
manifest: introduce memmanifestctx and memtreemanifestctx
Durham Goode <durham@fb.com>
parents:
30341
diff
changeset
|
2001 class memmanifestctx(object): |
31153
5cab44fd1257
manifest: remove _repo from manifestctx objects
Durham Goode <durham@fb.com>
parents:
31151
diff
changeset
|
2002 def __init__(self, manifestlog): |
5cab44fd1257
manifest: remove _repo from manifestctx objects
Durham Goode <durham@fb.com>
parents:
31151
diff
changeset
|
2003 self._manifestlog = manifestlog |
30342
fe1ee393de78
manifest: introduce memmanifestctx and memtreemanifestctx
Durham Goode <durham@fb.com>
parents:
30341
diff
changeset
|
2004 self._manifestdict = manifestdict() |
fe1ee393de78
manifest: introduce memmanifestctx and memtreemanifestctx
Durham Goode <durham@fb.com>
parents:
30341
diff
changeset
|
2005 |
39317
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2006 def _storage(self): |
39320
57301ba47e66
manifest: use public API for obtaining storage object
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39317
diff
changeset
|
2007 return self._manifestlog.getstorage(b'') |
30345
fa54f7ade491
manifest: remove manifest.add and add memmfctx.write
Durham Goode <durham@fb.com>
parents:
30343
diff
changeset
|
2008 |
30343
952e1916ae56
manifest: add copy to mfctx classes
Durham Goode <durham@fb.com>
parents:
30342
diff
changeset
|
2009 def copy(self): |
31153
5cab44fd1257
manifest: remove _repo from manifestctx objects
Durham Goode <durham@fb.com>
parents:
31151
diff
changeset
|
2010 memmf = memmanifestctx(self._manifestlog) |
30343
952e1916ae56
manifest: add copy to mfctx classes
Durham Goode <durham@fb.com>
parents:
30342
diff
changeset
|
2011 memmf._manifestdict = self.read().copy() |
952e1916ae56
manifest: add copy to mfctx classes
Durham Goode <durham@fb.com>
parents:
30342
diff
changeset
|
2012 return memmf |
952e1916ae56
manifest: add copy to mfctx classes
Durham Goode <durham@fb.com>
parents:
30342
diff
changeset
|
2013 |
30342
fe1ee393de78
manifest: introduce memmanifestctx and memtreemanifestctx
Durham Goode <durham@fb.com>
parents:
30341
diff
changeset
|
2014 def read(self): |
fe1ee393de78
manifest: introduce memmanifestctx and memtreemanifestctx
Durham Goode <durham@fb.com>
parents:
30341
diff
changeset
|
2015 return self._manifestdict |
fe1ee393de78
manifest: introduce memmanifestctx and memtreemanifestctx
Durham Goode <durham@fb.com>
parents:
30341
diff
changeset
|
2016 |
39668
24870f1be088
narrow: when writing treemanifests, skip inspecting directories outside narrow
spectral <spectral@google.com>
parents:
39522
diff
changeset
|
2017 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
|
2018 return self._storage().add( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2019 self._manifestdict, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2020 transaction, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2021 link, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2022 p1, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2023 p2, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2024 added, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2025 removed, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2026 match=match, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2027 ) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2028 |
30345
fa54f7ade491
manifest: remove manifest.add and add memmfctx.write
Durham Goode <durham@fb.com>
parents:
30343
diff
changeset
|
2029 |
38530
c82ea938efbb
repository: define manifest interfaces
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38510
diff
changeset
|
2030 @interfaceutil.implementer(repository.imanifestrevisionstored) |
29926
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2031 class manifestctx(object): |
29825
426d931e5db2
manifest: introduce manifestlog and manifestctx classes
Durham Goode <durham@fb.com>
parents:
29824
diff
changeset
|
2032 """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
|
2033 contents, its parent revs, and its linkrev. |
426d931e5db2
manifest: introduce manifestlog and manifestctx classes
Durham Goode <durham@fb.com>
parents:
29824
diff
changeset
|
2034 """ |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2035 |
31153
5cab44fd1257
manifest: remove _repo from manifestctx objects
Durham Goode <durham@fb.com>
parents:
31151
diff
changeset
|
2036 def __init__(self, manifestlog, node): |
5cab44fd1257
manifest: remove _repo from manifestctx objects
Durham Goode <durham@fb.com>
parents:
31151
diff
changeset
|
2037 self._manifestlog = manifestlog |
29926
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2038 self._data = None |
29825
426d931e5db2
manifest: introduce manifestlog and manifestctx classes
Durham Goode <durham@fb.com>
parents:
29824
diff
changeset
|
2039 |
426d931e5db2
manifest: introduce manifestlog and manifestctx classes
Durham Goode <durham@fb.com>
parents:
29824
diff
changeset
|
2040 self._node = node |
29907
4fb4fc331699
manifest: add treemanifestctx class
Durham Goode <durham@fb.com>
parents:
29888
diff
changeset
|
2041 |
4fb4fc331699
manifest: add treemanifestctx class
Durham Goode <durham@fb.com>
parents:
29888
diff
changeset
|
2042 # 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
|
2043 # 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
|
2044 # lazily. |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2045 # self.p1, self.p2 = store.parents(node) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2046 # rev = store.rev(node) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2047 # self.linkrev = store.linkrev(rev) |
29825
426d931e5db2
manifest: introduce manifestlog and manifestctx classes
Durham Goode <durham@fb.com>
parents:
29824
diff
changeset
|
2048 |
39317
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2049 def _storage(self): |
39320
57301ba47e66
manifest: use public API for obtaining storage object
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39317
diff
changeset
|
2050 return self._manifestlog.getstorage(b'') |
30341
3dfb5a0171c9
manifestctx: add _revlog() function
Durham Goode <durham@fb.com>
parents:
30340
diff
changeset
|
2051 |
29825
426d931e5db2
manifest: introduce manifestlog and manifestctx classes
Durham Goode <durham@fb.com>
parents:
29824
diff
changeset
|
2052 def node(self): |
426d931e5db2
manifest: introduce manifestlog and manifestctx classes
Durham Goode <durham@fb.com>
parents:
29824
diff
changeset
|
2053 return self._node |
426d931e5db2
manifest: introduce manifestlog and manifestctx classes
Durham Goode <durham@fb.com>
parents:
29824
diff
changeset
|
2054 |
30343
952e1916ae56
manifest: add copy to mfctx classes
Durham Goode <durham@fb.com>
parents:
30342
diff
changeset
|
2055 def copy(self): |
31153
5cab44fd1257
manifest: remove _repo from manifestctx objects
Durham Goode <durham@fb.com>
parents:
31151
diff
changeset
|
2056 memmf = memmanifestctx(self._manifestlog) |
30343
952e1916ae56
manifest: add copy to mfctx classes
Durham Goode <durham@fb.com>
parents:
30342
diff
changeset
|
2057 memmf._manifestdict = self.read().copy() |
952e1916ae56
manifest: add copy to mfctx classes
Durham Goode <durham@fb.com>
parents:
30342
diff
changeset
|
2058 return memmf |
952e1916ae56
manifest: add copy to mfctx classes
Durham Goode <durham@fb.com>
parents:
30342
diff
changeset
|
2059 |
30565
7fbc8a742b4d
manifest: expose the parents() method
Mateusz Kwapich <mitrandir@fb.com>
parents:
30443
diff
changeset
|
2060 @propertycache |
7fbc8a742b4d
manifest: expose the parents() method
Mateusz Kwapich <mitrandir@fb.com>
parents:
30443
diff
changeset
|
2061 def parents(self): |
39317
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2062 return self._storage().parents(self._node) |
30565
7fbc8a742b4d
manifest: expose the parents() method
Mateusz Kwapich <mitrandir@fb.com>
parents:
30443
diff
changeset
|
2063 |
29926
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2064 def read(self): |
31097
4a1486c73fdf
manifest: check 'if x is None' instead of 'if not x'
Durham Goode <durham@fb.com>
parents:
30565
diff
changeset
|
2065 if self._data is None: |
39316
53363a8eff57
manifest: don't go through revlog to access node symbols
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39315
diff
changeset
|
2066 if self._node == nullid: |
29926
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2067 self._data = manifestdict() |
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2068 else: |
39317
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2069 store = self._storage() |
39322
5886384d1ac5
manifest: use fulltextcache instead of _fulltextcache
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39321
diff
changeset
|
2070 if self._node in store.fulltextcache: |
5886384d1ac5
manifest: use fulltextcache instead of _fulltextcache
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39321
diff
changeset
|
2071 text = pycompat.bytestr(store.fulltextcache[self._node]) |
38781
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
2072 else: |
39317
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2073 text = store.revision(self._node) |
38781
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
2074 arraytext = bytearray(text) |
39322
5886384d1ac5
manifest: use fulltextcache instead of _fulltextcache
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39321
diff
changeset
|
2075 store.fulltextcache[self._node] = arraytext |
29926
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2076 self._data = manifestdict(text) |
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2077 return self._data |
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2078 |
30293
78f3c7166f0d
manifest: add shallow option to treemanifestctx.readdelta and readfast
Durham Goode <durham@fb.com>
parents:
30292
diff
changeset
|
2079 def readfast(self, shallow=False): |
30294
bce79dfcf5e4
manifest: get rid of manifest.readshallowfast
Durham Goode <durham@fb.com>
parents:
30293
diff
changeset
|
2080 '''Calls either readdelta or read, based on which would be less work. |
bce79dfcf5e4
manifest: get rid of manifest.readshallowfast
Durham Goode <durham@fb.com>
parents:
30293
diff
changeset
|
2081 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
|
2082 read quickly. |
bce79dfcf5e4
manifest: get rid of manifest.readshallowfast
Durham Goode <durham@fb.com>
parents:
30293
diff
changeset
|
2083 |
bce79dfcf5e4
manifest: get rid of manifest.readshallowfast
Durham Goode <durham@fb.com>
parents:
30293
diff
changeset
|
2084 If `shallow` is True, nothing changes since this is a flat manifest. |
bce79dfcf5e4
manifest: get rid of manifest.readshallowfast
Durham Goode <durham@fb.com>
parents:
30293
diff
changeset
|
2085 ''' |
39317
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2086 store = self._storage() |
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2087 r = store.rev(self._node) |
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2088 deltaparent = store.deltaparent(r) |
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2089 if deltaparent != nullrev and deltaparent in store.parentrevs(r): |
29939
80be4436e4cc
manifest: adds manifestctx.readfast
Durham Goode <durham@fb.com>
parents:
29938
diff
changeset
|
2090 return self.readdelta() |
80be4436e4cc
manifest: adds manifestctx.readfast
Durham Goode <durham@fb.com>
parents:
29938
diff
changeset
|
2091 return self.read() |
80be4436e4cc
manifest: adds manifestctx.readfast
Durham Goode <durham@fb.com>
parents:
29938
diff
changeset
|
2092 |
30293
78f3c7166f0d
manifest: add shallow option to treemanifestctx.readdelta and readfast
Durham Goode <durham@fb.com>
parents:
30292
diff
changeset
|
2093 def readdelta(self, shallow=False): |
30295
f65faa4422c8
manifest: remove manifest.readshallowdelta
Durham Goode <durham@fb.com>
parents:
30294
diff
changeset
|
2094 '''Returns a manifest containing just the entries that are present |
f65faa4422c8
manifest: remove manifest.readshallowdelta
Durham Goode <durham@fb.com>
parents:
30294
diff
changeset
|
2095 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
|
2096 if the revlog delta is already p1. |
f65faa4422c8
manifest: remove manifest.readshallowdelta
Durham Goode <durham@fb.com>
parents:
30294
diff
changeset
|
2097 |
f65faa4422c8
manifest: remove manifest.readshallowdelta
Durham Goode <durham@fb.com>
parents:
30294
diff
changeset
|
2098 Changing the value of `shallow` has no effect on flat manifests. |
f65faa4422c8
manifest: remove manifest.readshallowdelta
Durham Goode <durham@fb.com>
parents:
30294
diff
changeset
|
2099 ''' |
39317
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2100 store = self._storage() |
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2101 r = store.rev(self._node) |
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2102 d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r)) |
29938
a059b17352ef
manifest: add manifestctx.readdelta()
Durham Goode <durham@fb.com>
parents:
29926
diff
changeset
|
2103 return manifestdict(d) |
a059b17352ef
manifest: add manifestctx.readdelta()
Durham Goode <durham@fb.com>
parents:
29926
diff
changeset
|
2104 |
30340
608ba935e041
manifest: remove manifest.find
Durham Goode <durham@fb.com>
parents:
30338
diff
changeset
|
2105 def find(self, key): |
608ba935e041
manifest: remove manifest.find
Durham Goode <durham@fb.com>
parents:
30338
diff
changeset
|
2106 return self.read().find(key) |
608ba935e041
manifest: remove manifest.find
Durham Goode <durham@fb.com>
parents:
30338
diff
changeset
|
2107 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2108 |
38530
c82ea938efbb
repository: define manifest interfaces
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38510
diff
changeset
|
2109 @interfaceutil.implementer(repository.imanifestrevisionwritable) |
30342
fe1ee393de78
manifest: introduce memmanifestctx and memtreemanifestctx
Durham Goode <durham@fb.com>
parents:
30341
diff
changeset
|
2110 class memtreemanifestctx(object): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
2111 def __init__(self, manifestlog, dir=b''): |
31153
5cab44fd1257
manifest: remove _repo from manifestctx objects
Durham Goode <durham@fb.com>
parents:
31151
diff
changeset
|
2112 self._manifestlog = manifestlog |
30342
fe1ee393de78
manifest: introduce memmanifestctx and memtreemanifestctx
Durham Goode <durham@fb.com>
parents:
30341
diff
changeset
|
2113 self._dir = dir |
fe1ee393de78
manifest: introduce memmanifestctx and memtreemanifestctx
Durham Goode <durham@fb.com>
parents:
30341
diff
changeset
|
2114 self._treemanifest = treemanifest() |
fe1ee393de78
manifest: introduce memmanifestctx and memtreemanifestctx
Durham Goode <durham@fb.com>
parents:
30341
diff
changeset
|
2115 |
39317
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2116 def _storage(self): |
39320
57301ba47e66
manifest: use public API for obtaining storage object
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39317
diff
changeset
|
2117 return self._manifestlog.getstorage(b'') |
30345
fa54f7ade491
manifest: remove manifest.add and add memmfctx.write
Durham Goode <durham@fb.com>
parents:
30343
diff
changeset
|
2118 |
30343
952e1916ae56
manifest: add copy to mfctx classes
Durham Goode <durham@fb.com>
parents:
30342
diff
changeset
|
2119 def copy(self): |
31153
5cab44fd1257
manifest: remove _repo from manifestctx objects
Durham Goode <durham@fb.com>
parents:
31151
diff
changeset
|
2120 memmf = memtreemanifestctx(self._manifestlog, dir=self._dir) |
30343
952e1916ae56
manifest: add copy to mfctx classes
Durham Goode <durham@fb.com>
parents:
30342
diff
changeset
|
2121 memmf._treemanifest = self._treemanifest.copy() |
952e1916ae56
manifest: add copy to mfctx classes
Durham Goode <durham@fb.com>
parents:
30342
diff
changeset
|
2122 return memmf |
952e1916ae56
manifest: add copy to mfctx classes
Durham Goode <durham@fb.com>
parents:
30342
diff
changeset
|
2123 |
30342
fe1ee393de78
manifest: introduce memmanifestctx and memtreemanifestctx
Durham Goode <durham@fb.com>
parents:
30341
diff
changeset
|
2124 def read(self): |
fe1ee393de78
manifest: introduce memmanifestctx and memtreemanifestctx
Durham Goode <durham@fb.com>
parents:
30341
diff
changeset
|
2125 return self._treemanifest |
fe1ee393de78
manifest: introduce memmanifestctx and memtreemanifestctx
Durham Goode <durham@fb.com>
parents:
30341
diff
changeset
|
2126 |
39668
24870f1be088
narrow: when writing treemanifests, skip inspecting directories outside narrow
spectral <spectral@google.com>
parents:
39522
diff
changeset
|
2127 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
|
2128 def readtree(dir, node): |
31153
5cab44fd1257
manifest: remove _repo from manifestctx objects
Durham Goode <durham@fb.com>
parents:
31151
diff
changeset
|
2129 return self._manifestlog.get(dir, node).read() |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2130 |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2131 return self._storage().add( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2132 self._treemanifest, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2133 transaction, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2134 link, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2135 p1, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2136 p2, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2137 added, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2138 removed, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2139 readtree=readtree, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2140 match=match, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2141 ) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2142 |
30345
fa54f7ade491
manifest: remove manifest.add and add memmfctx.write
Durham Goode <durham@fb.com>
parents:
30343
diff
changeset
|
2143 |
38530
c82ea938efbb
repository: define manifest interfaces
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38510
diff
changeset
|
2144 @interfaceutil.implementer(repository.imanifestrevisionstored) |
29926
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2145 class treemanifestctx(object): |
31153
5cab44fd1257
manifest: remove _repo from manifestctx objects
Durham Goode <durham@fb.com>
parents:
31151
diff
changeset
|
2146 def __init__(self, manifestlog, dir, node): |
5cab44fd1257
manifest: remove _repo from manifestctx objects
Durham Goode <durham@fb.com>
parents:
31151
diff
changeset
|
2147 self._manifestlog = manifestlog |
29907
4fb4fc331699
manifest: add treemanifestctx class
Durham Goode <durham@fb.com>
parents:
29888
diff
changeset
|
2148 self._dir = dir |
29926
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2149 self._data = None |
29907
4fb4fc331699
manifest: add treemanifestctx class
Durham Goode <durham@fb.com>
parents:
29888
diff
changeset
|
2150 |
4fb4fc331699
manifest: add treemanifestctx class
Durham Goode <durham@fb.com>
parents:
29888
diff
changeset
|
2151 self._node = node |
4fb4fc331699
manifest: add treemanifestctx class
Durham Goode <durham@fb.com>
parents:
29888
diff
changeset
|
2152 |
4fb4fc331699
manifest: add treemanifestctx class
Durham Goode <durham@fb.com>
parents:
29888
diff
changeset
|
2153 # 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
|
2154 # we can instantiate treemanifestctx objects for directories we don't |
4fb4fc331699
manifest: add treemanifestctx class
Durham Goode <durham@fb.com>
parents:
29888
diff
changeset
|
2155 # have on disk. |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2156 # self.p1, self.p2 = store.parents(node) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2157 # rev = store.rev(node) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2158 # self.linkrev = store.linkrev(rev) |
29907
4fb4fc331699
manifest: add treemanifestctx class
Durham Goode <durham@fb.com>
parents:
29888
diff
changeset
|
2159 |
39317
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2160 def _storage(self): |
37373
c50078fc32f3
narrow: move manifestrevlog overrides to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37372
diff
changeset
|
2161 narrowmatch = self._manifestlog._narrowmatch |
c50078fc32f3
narrow: move manifestrevlog overrides to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37372
diff
changeset
|
2162 if not narrowmatch.always(): |
42341
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41965
diff
changeset
|
2163 if not narrowmatch.visitdir(self._dir[:-1]): |
37373
c50078fc32f3
narrow: move manifestrevlog overrides to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37372
diff
changeset
|
2164 return excludedmanifestrevlog(self._dir) |
39244
73cf21b2e8a6
manifest: add getstorage() to manifestlog and use it globally
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39243
diff
changeset
|
2165 return self._manifestlog.getstorage(self._dir) |
30221
f2c5b9d48b29
manifest: make treemanifestctx store the repo
Durham Goode <durham@fb.com>
parents:
30220
diff
changeset
|
2166 |
29926
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2167 def read(self): |
31097
4a1486c73fdf
manifest: check 'if x is None' instead of 'if not x'
Durham Goode <durham@fb.com>
parents:
30565
diff
changeset
|
2168 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
|
2169 store = self._storage() |
39316
53363a8eff57
manifest: don't go through revlog to access node symbols
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39315
diff
changeset
|
2170 if self._node == nullid: |
29926
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2171 self._data = treemanifest() |
39317
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2172 # TODO accessing non-public API |
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2173 elif store._treeondisk: |
29926
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2174 m = treemanifest(dir=self._dir) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2175 |
29926
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2176 def gettext(): |
39317
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2177 return store.revision(self._node) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2178 |
29926
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2179 def readsubtree(dir, subm): |
30404
a1beadaa4061
manifest: change treemanifestctx to construct subtrees from the manifestlog
Durham Goode <durham@fb.com>
parents:
30403
diff
changeset
|
2180 # 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
|
2181 # 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
|
2182 return self._manifestlog.get(dir, subm, verify=False).read() |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2183 |
29926
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2184 m.read(gettext, readsubtree) |
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2185 m.setnode(self._node) |
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2186 self._data = m |
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2187 else: |
39317
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2188 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
|
2189 text = pycompat.bytestr(store.fulltextcache[self._node]) |
38781
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
2190 else: |
39317
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2191 text = store.revision(self._node) |
38781
0a57945aaf7f
manifest: persist the manifestfulltext cache
Martijn Pieters <mj@zopatista.com>
parents:
38657
diff
changeset
|
2192 arraytext = bytearray(text) |
39317
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2193 store.fulltextcache[self._node] = arraytext |
29926
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2194 self._data = treemanifest(dir=self._dir, text=text) |
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2195 |
be16091ac14d
manifest: change manifestctx to not inherit from manifestdict
Durham Goode <durham@fb.com>
parents:
29916
diff
changeset
|
2196 return self._data |
29907
4fb4fc331699
manifest: add treemanifestctx class
Durham Goode <durham@fb.com>
parents:
29888
diff
changeset
|
2197 |
4fb4fc331699
manifest: add treemanifestctx class
Durham Goode <durham@fb.com>
parents:
29888
diff
changeset
|
2198 def node(self): |
4fb4fc331699
manifest: add treemanifestctx class
Durham Goode <durham@fb.com>
parents:
29888
diff
changeset
|
2199 return self._node |
4fb4fc331699
manifest: add treemanifestctx class
Durham Goode <durham@fb.com>
parents:
29888
diff
changeset
|
2200 |
30343
952e1916ae56
manifest: add copy to mfctx classes
Durham Goode <durham@fb.com>
parents:
30342
diff
changeset
|
2201 def copy(self): |
31153
5cab44fd1257
manifest: remove _repo from manifestctx objects
Durham Goode <durham@fb.com>
parents:
31151
diff
changeset
|
2202 memmf = memtreemanifestctx(self._manifestlog, dir=self._dir) |
30343
952e1916ae56
manifest: add copy to mfctx classes
Durham Goode <durham@fb.com>
parents:
30342
diff
changeset
|
2203 memmf._treemanifest = self.read().copy() |
952e1916ae56
manifest: add copy to mfctx classes
Durham Goode <durham@fb.com>
parents:
30342
diff
changeset
|
2204 return memmf |
952e1916ae56
manifest: add copy to mfctx classes
Durham Goode <durham@fb.com>
parents:
30342
diff
changeset
|
2205 |
30565
7fbc8a742b4d
manifest: expose the parents() method
Mateusz Kwapich <mitrandir@fb.com>
parents:
30443
diff
changeset
|
2206 @propertycache |
7fbc8a742b4d
manifest: expose the parents() method
Mateusz Kwapich <mitrandir@fb.com>
parents:
30443
diff
changeset
|
2207 def parents(self): |
39317
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2208 return self._storage().parents(self._node) |
30565
7fbc8a742b4d
manifest: expose the parents() method
Mateusz Kwapich <mitrandir@fb.com>
parents:
30443
diff
changeset
|
2209 |
30293
78f3c7166f0d
manifest: add shallow option to treemanifestctx.readdelta and readfast
Durham Goode <durham@fb.com>
parents:
30292
diff
changeset
|
2210 def readdelta(self, shallow=False): |
30295
f65faa4422c8
manifest: remove manifest.readshallowdelta
Durham Goode <durham@fb.com>
parents:
30294
diff
changeset
|
2211 '''Returns a manifest containing just the entries that are present |
f65faa4422c8
manifest: remove manifest.readshallowdelta
Durham Goode <durham@fb.com>
parents:
30294
diff
changeset
|
2212 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
|
2213 if the revlog delta is already p1. |
f65faa4422c8
manifest: remove manifest.readshallowdelta
Durham Goode <durham@fb.com>
parents:
30294
diff
changeset
|
2214 |
f65faa4422c8
manifest: remove manifest.readshallowdelta
Durham Goode <durham@fb.com>
parents:
30294
diff
changeset
|
2215 If `shallow` is True, this will read the delta for this directory, |
f65faa4422c8
manifest: remove manifest.readshallowdelta
Durham Goode <durham@fb.com>
parents:
30294
diff
changeset
|
2216 without recursively reading subdirectory manifests. Instead, any |
f65faa4422c8
manifest: remove manifest.readshallowdelta
Durham Goode <durham@fb.com>
parents:
30294
diff
changeset
|
2217 subdirectory entry will be reported as it appears in the manifest, i.e. |
f65faa4422c8
manifest: remove manifest.readshallowdelta
Durham Goode <durham@fb.com>
parents:
30294
diff
changeset
|
2218 the subdirectory will be reported among files and distinguished only by |
f65faa4422c8
manifest: remove manifest.readshallowdelta
Durham Goode <durham@fb.com>
parents:
30294
diff
changeset
|
2219 its 't' flag. |
f65faa4422c8
manifest: remove manifest.readshallowdelta
Durham Goode <durham@fb.com>
parents:
30294
diff
changeset
|
2220 ''' |
39317
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2221 store = self._storage() |
36373
0147a4730420
cleanup: say goodbye to manifestv2 format
Augie Fackler <augie@google.com>
parents:
36301
diff
changeset
|
2222 if shallow: |
39317
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2223 r = store.rev(self._node) |
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2224 d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r)) |
30293
78f3c7166f0d
manifest: add shallow option to treemanifestctx.readdelta and readfast
Durham Goode <durham@fb.com>
parents:
30292
diff
changeset
|
2225 return manifestdict(d) |
78f3c7166f0d
manifest: add shallow option to treemanifestctx.readdelta and readfast
Durham Goode <durham@fb.com>
parents:
30292
diff
changeset
|
2226 else: |
78f3c7166f0d
manifest: add shallow option to treemanifestctx.readdelta and readfast
Durham Goode <durham@fb.com>
parents:
30292
diff
changeset
|
2227 # 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
|
2228 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
|
2229 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
|
2230 m1 = self.read() |
78f3c7166f0d
manifest: add shallow option to treemanifestctx.readdelta and readfast
Durham Goode <durham@fb.com>
parents:
30292
diff
changeset
|
2231 md = treemanifest(dir=self._dir) |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43089
diff
changeset
|
2232 for f, ((n0, fl0), (n1, fl1)) in pycompat.iteritems(m0.diff(m1)): |
30293
78f3c7166f0d
manifest: add shallow option to treemanifestctx.readdelta and readfast
Durham Goode <durham@fb.com>
parents:
30292
diff
changeset
|
2233 if n1: |
78f3c7166f0d
manifest: add shallow option to treemanifestctx.readdelta and readfast
Durham Goode <durham@fb.com>
parents:
30292
diff
changeset
|
2234 md[f] = n1 |
78f3c7166f0d
manifest: add shallow option to treemanifestctx.readdelta and readfast
Durham Goode <durham@fb.com>
parents:
30292
diff
changeset
|
2235 if fl1: |
78f3c7166f0d
manifest: add shallow option to treemanifestctx.readdelta and readfast
Durham Goode <durham@fb.com>
parents:
30292
diff
changeset
|
2236 md.setflag(f, fl1) |
78f3c7166f0d
manifest: add shallow option to treemanifestctx.readdelta and readfast
Durham Goode <durham@fb.com>
parents:
30292
diff
changeset
|
2237 return md |
29938
a059b17352ef
manifest: add manifestctx.readdelta()
Durham Goode <durham@fb.com>
parents:
29926
diff
changeset
|
2238 |
30293
78f3c7166f0d
manifest: add shallow option to treemanifestctx.readdelta and readfast
Durham Goode <durham@fb.com>
parents:
30292
diff
changeset
|
2239 def readfast(self, shallow=False): |
30294
bce79dfcf5e4
manifest: get rid of manifest.readshallowfast
Durham Goode <durham@fb.com>
parents:
30293
diff
changeset
|
2240 '''Calls either readdelta or read, based on which would be less work. |
bce79dfcf5e4
manifest: get rid of manifest.readshallowfast
Durham Goode <durham@fb.com>
parents:
30293
diff
changeset
|
2241 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
|
2242 read quickly. |
bce79dfcf5e4
manifest: get rid of manifest.readshallowfast
Durham Goode <durham@fb.com>
parents:
30293
diff
changeset
|
2243 |
bce79dfcf5e4
manifest: get rid of manifest.readshallowfast
Durham Goode <durham@fb.com>
parents:
30293
diff
changeset
|
2244 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
|
2245 and not any submanifests. |
bce79dfcf5e4
manifest: get rid of manifest.readshallowfast
Durham Goode <durham@fb.com>
parents:
30293
diff
changeset
|
2246 ''' |
39317
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2247 store = self._storage() |
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2248 r = store.rev(self._node) |
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2249 deltaparent = store.deltaparent(r) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2250 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
|
2251 return self.readdelta(shallow=shallow) |
78f3c7166f0d
manifest: add shallow option to treemanifestctx.readdelta and readfast
Durham Goode <durham@fb.com>
parents:
30292
diff
changeset
|
2252 |
78f3c7166f0d
manifest: add shallow option to treemanifestctx.readdelta and readfast
Durham Goode <durham@fb.com>
parents:
30292
diff
changeset
|
2253 if shallow: |
39317
eb9b8679c852
manifest: change terminology for storage in context classes
Gregory Szorc <gregory.szorc@gmail.com>
parents:
39316
diff
changeset
|
2254 return manifestdict(store.revision(self._node)) |
30293
78f3c7166f0d
manifest: add shallow option to treemanifestctx.readdelta and readfast
Durham Goode <durham@fb.com>
parents:
30292
diff
changeset
|
2255 else: |
78f3c7166f0d
manifest: add shallow option to treemanifestctx.readdelta and readfast
Durham Goode <durham@fb.com>
parents:
30292
diff
changeset
|
2256 return self.read() |
29939
80be4436e4cc
manifest: adds manifestctx.readfast
Durham Goode <durham@fb.com>
parents:
29938
diff
changeset
|
2257 |
30340
608ba935e041
manifest: remove manifest.find
Durham Goode <durham@fb.com>
parents:
30338
diff
changeset
|
2258 def find(self, key): |
608ba935e041
manifest: remove manifest.find
Durham Goode <durham@fb.com>
parents:
30338
diff
changeset
|
2259 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
|
2260 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2261 |
37372
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2262 class excludeddir(treemanifest): |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2263 """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
|
2264 |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2265 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
|
2266 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
|
2267 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
|
2268 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
|
2269 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
|
2270 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
|
2271 whose contents are unknown. |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2272 """ |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2273 |
37372
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2274 def __init__(self, dir, node): |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2275 super(excludeddir, self).__init__(dir) |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2276 self._node = node |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2277 # 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
|
2278 # 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
|
2279 self._files[b''] = node |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
2280 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
|
2281 |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2282 # 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
|
2283 # 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
|
2284 # 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
|
2285 # 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
|
2286 # super type's copy(). |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2287 def copy(self): |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2288 return self |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2289 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2290 |
37372
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2291 class excludeddirmanifestctx(treemanifestctx): |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2292 """context wrapper for excludeddir - see that docstring for rationale""" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2293 |
37372
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2294 def __init__(self, dir, node): |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2295 self._dir = dir |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2296 self._node = node |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2297 |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2298 def read(self): |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2299 return excludeddir(self._dir, self._node) |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2300 |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2301 def write(self, *args): |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2302 raise error.ProgrammingError( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
2303 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
|
2304 ) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42814
diff
changeset
|
2305 |
37372
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2306 |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2307 class excludedmanifestrevlog(manifestrevlog): |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2308 """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
|
2309 |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2310 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
|
2311 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
|
2312 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
|
2313 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
|
2314 outside the narrowspec. |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2315 """ |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2316 |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2317 def __init__(self, dir): |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2318 self._dir = dir |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2319 |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2320 def __len__(self): |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2321 raise error.ProgrammingError( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
2322 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
|
2323 ) |
37372
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2324 |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2325 def rev(self, node): |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2326 raise error.ProgrammingError( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
2327 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
|
2328 ) |
37372
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2329 |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2330 def linkrev(self, node): |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2331 raise error.ProgrammingError( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
2332 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
|
2333 ) |
37372
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2334 |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2335 def node(self, rev): |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2336 raise error.ProgrammingError( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
2337 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
|
2338 ) |
37372
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2339 |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2340 def add(self, *args, **kwargs): |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2341 # 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
|
2342 # 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
|
2343 # _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
|
2344 # 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
|
2345 # in excludeddir instances). |
1b2fa531fd7a
narrow: move excludeddir and related classes to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
37270
diff
changeset
|
2346 pass |