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

annotate mercurial/manifest.py @ 38557:0db41eb0a3ac

manifest: define and implement addgroup() on manifestlog Changegroup code was bypassing our manifest interface and calling a method on the private revlog attribute. This commit formalizes the interface for adding a group of revisions from deltas and changes the changegroup code to use it. This enables alternate manifest storage to work with changegroup application operations (like `hg unbundle` and `hg pull`). Differential Revision: https://phab.mercurial-scm.org/D3883

author	Gregory Szorc <gregory.szorc@gmail.com>
date	Sun, 01 Jul 2018 14:25:44 -0700
parents	f2f9bacf0587
children	28c9d67d88ab

rev	line source
1089 142b5d5ec9cc Break apart hg.py mpm@selenic.com parents: 1072 diff changeset	1 # manifest.py - manifest revision class for mercurial
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	2 #
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 25e572394f5c Update license to GPLv2+ Matt Mackall <mpm@selenic.com> parents: 9420 diff changeset	6 # GNU General Public License version 2 or any later version.
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	7
27502 2df7f5c09c34 manifest: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27466 diff changeset	8 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
32569 aa333c1982ab manifest: use itertools.chain() instead of + for Python 3 compat Augie Fackler <raf@durin42.com> parents: 32568 diff changeset	11 import itertools
27502 2df7f5c09c34 manifest: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27466 diff changeset	12 import struct
2df7f5c09c34 manifest: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27466 diff changeset	13
2df7f5c09c34 manifest: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27466 diff changeset	14 from .i18n import _
31536 160e7ad941e9 manifest: use node.hex instead of .encode('hex') Augie Fackler <augie@google.com> parents: 31483 diff changeset	15 from .node import (
160e7ad941e9 manifest: use node.hex instead of .encode('hex') Augie Fackler <augie@google.com> parents: 31483 diff changeset	16 bin,
160e7ad941e9 manifest: use node.hex instead of .encode('hex') Augie Fackler <augie@google.com> parents: 31483 diff changeset	17 hex,
160e7ad941e9 manifest: use node.hex instead of .encode('hex') Augie Fackler <augie@google.com> parents: 31483 diff changeset	18 )
27502 2df7f5c09c34 manifest: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27466 diff changeset	19 from . import (
2df7f5c09c34 manifest: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27466 diff changeset	20 error,
2df7f5c09c34 manifest: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27466 diff changeset	21 mdiff,
32411 df448de7cf3b parsers: switch to policy importer Yuya Nishihara <yuya@tcha.org> parents: 32292 diff changeset	22 policy,
38340 cf59de802883 py3: remove b'' from error message of disallowed filename Yuya Nishihara <yuya@tcha.org> parents: 37374 diff changeset	23 pycompat,
38532 c82ea938efbb repository: define manifest interfaces Gregory Szorc <gregory.szorc@gmail.com> parents: 38514 diff changeset	24 repository,
27502 2df7f5c09c34 manifest: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27466 diff changeset	25 revlog,
2df7f5c09c34 manifest: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27466 diff changeset	26 util,
2df7f5c09c34 manifest: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27466 diff changeset	27 )
38532 c82ea938efbb repository: define manifest interfaces Gregory Szorc <gregory.szorc@gmail.com> parents: 38514 diff changeset	28 from .utils import (
c82ea938efbb repository: define manifest interfaces Gregory Szorc <gregory.szorc@gmail.com> parents: 38514 diff changeset	29 interfaceutil,
c82ea938efbb repository: define manifest interfaces Gregory Szorc <gregory.szorc@gmail.com> parents: 38514 diff changeset	30 )
79 837d473d54d5 Add basic annotation support mpm@selenic.com parents: 78 diff changeset	31
32411 df448de7cf3b parsers: switch to policy importer Yuya Nishihara <yuya@tcha.org> parents: 32292 diff changeset	32 parsers = policy.importmod(r'parsers')
24322 f263814c72ac manifest: add dirs() to manifestdict Drew Gottlieb <drgott@google.com> parents: 24298 diff changeset	33 propertycache = util.propertycache
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	34
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	35 def _parse(data):
24524 63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	36 # 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	37 # 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	38 # 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	39 # 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	40 # the pure version.
32568 260a6f715bd2 manifest: fix some pure-Python parser bits to work on Python 3 Augie Fackler <raf@durin42.com> parents: 32411 diff changeset	41 if data and data[-1:] != '\n':
24524 63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	42 raise ValueError('Manifest did not end in a newline.')
63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	43 prev = None
63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	44 for l in data.splitlines():
63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	45 if prev is not None and prev > l:
63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	46 raise ValueError('Manifest lines not in sorted order.')
63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	47 prev = l
63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	48 f, n = l.split('\0')
63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	49 if len(n) > 40:
31375 45347d4a4f07 manifest: now that node.bin is available, use it directly Augie Fackler <augie@google.com> parents: 31374 diff changeset	50 yield f, bin(n[:40]), n[40:]
24524 63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	51 else:
31375 45347d4a4f07 manifest: now that node.bin is available, use it directly Augie Fackler <augie@google.com> parents: 31374 diff changeset	52 yield f, bin(n), ''
24524 63b6031384fc manifest: extract method for parsing manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24502 diff changeset	53
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	54 def _text(it):
24525 e118f74d246f manifest: extract method for creating manifest text Martin von Zweigbergk <martinvonz@google.com> parents: 24524 diff changeset	55 files = []
e118f74d246f manifest: extract method for creating manifest text Martin von Zweigbergk <martinvonz@google.com> parents: 24524 diff changeset	56 lines = []
e118f74d246f manifest: extract method for creating manifest text Martin von Zweigbergk <martinvonz@google.com> parents: 24524 diff changeset	57 _hex = revlog.hex
e118f74d246f manifest: extract method for creating manifest text Martin von Zweigbergk <martinvonz@google.com> parents: 24524 diff changeset	58 for f, n, fl in it:
e118f74d246f manifest: extract method for creating manifest text Martin von Zweigbergk <martinvonz@google.com> parents: 24524 diff changeset	59 files.append(f)
e118f74d246f manifest: extract method for creating manifest text Martin von Zweigbergk <martinvonz@google.com> parents: 24524 diff changeset	60 # 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	61 # be sure to check the templates/ dir again (especially *-raw.tmpl)
e118f74d246f manifest: extract method for creating manifest text Martin von Zweigbergk <martinvonz@google.com> parents: 24524 diff changeset	62 lines.append("%s\0%s%s\n" % (f, _hex(n), fl))
e118f74d246f manifest: extract method for creating manifest text Martin von Zweigbergk <martinvonz@google.com> parents: 24524 diff changeset	63
e118f74d246f manifest: extract method for creating manifest text Martin von Zweigbergk <martinvonz@google.com> parents: 24524 diff changeset	64 _checkforbidden(files)
e118f74d246f manifest: extract method for creating manifest text Martin von Zweigbergk <martinvonz@google.com> parents: 24524 diff changeset	65 return ''.join(lines)
e118f74d246f manifest: extract method for creating manifest text Martin von Zweigbergk <martinvonz@google.com> parents: 24524 diff changeset	66
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	67 class lazymanifestiter(object):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	68 def __init__(self, lm):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	69 self.pos = 0
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	70 self.lm = lm
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	71
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	72 def __iter__(self):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	73 return self
24223 b4df0d0c49e7 manifest: move parsing functions up in file Augie Fackler <augie@google.com> parents: 24215 diff changeset	74
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	75 def next(self):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	76 try:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	77 data, pos = self.lm._get(self.pos)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	78 except IndexError:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	79 raise StopIteration
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	80 if pos == -1:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	81 self.pos += 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	82 return data[0]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	83 self.pos += 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	84 zeropos = data.find('\x00', pos)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	85 return data[pos:zeropos]
24224 d71837d06597 manifest: do parsing inside manifestdict contstructor Augie Fackler <augie@google.com> parents: 24223 diff changeset	86
31373 91874c247d61 manifest: add __next__ methods for Python 3 Augie Fackler <augie@google.com> parents: 31361 diff changeset	87 __next__ = next
91874c247d61 manifest: add __next__ methods for Python 3 Augie Fackler <augie@google.com> parents: 31361 diff changeset	88
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	89 class lazymanifestiterentries(object):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	90 def __init__(self, lm):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	91 self.lm = lm
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	92 self.pos = 0
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	93
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	94 def __iter__(self):
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	95 return self
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	96
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	97 def next(self):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	98 try:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	99 data, pos = self.lm._get(self.pos)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	100 except IndexError:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	101 raise StopIteration
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	102 if pos == -1:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	103 self.pos += 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	104 return data
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	105 zeropos = data.find('\x00', pos)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	106 hashval = unhexlify(data, self.lm.extrainfo[self.pos],
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	107 zeropos + 1, 40)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	108 flags = self.lm._getflags(data, self.pos, zeropos)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	109 self.pos += 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	110 return (data[pos:zeropos], hashval, flags)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	111
31373 91874c247d61 manifest: add __next__ methods for Python 3 Augie Fackler <augie@google.com> parents: 31361 diff changeset	112 __next__ = next
91874c247d61 manifest: add __next__ methods for Python 3 Augie Fackler <augie@google.com> parents: 31361 diff changeset	113
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	114 def unhexlify(data, extra, pos, length):
31374 28e3471a21ef manifest: use node.bin instead of .decode('hex') Augie Fackler <augie@google.com> parents: 31373 diff changeset	115 s = bin(data[pos:pos + length])
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	116 if extra:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	117 s += chr(extra & 0xff)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	118 return s
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	119
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	120 def _cmp(a, b):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	121 return (a > b) - (a < b)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	122
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	123 class _lazymanifest(object):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	124 def __init__(self, data, positions=None, extrainfo=None, extradata=None):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	125 if positions is None:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	126 self.positions = self.findlines(data)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	127 self.extrainfo = [0] * len(self.positions)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	128 self.data = data
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	129 self.extradata = []
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	130 else:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	131 self.positions = positions[:]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	132 self.extrainfo = extrainfo[:]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	133 self.extradata = extradata[:]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	134 self.data = data
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	135
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	136 def findlines(self, data):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	137 if not data:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	138 return []
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	139 pos = data.find("\n")
31361 667e88568087 manifest: unbreak pure-python manifest parsing on Python 3 Augie Fackler <augie@google.com> parents: 31355 diff changeset	140 if pos == -1 or data[-1:] != '\n':
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	141 raise ValueError("Manifest did not end in a newline.")
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	142 positions = [0]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	143 prev = data[:data.find('\x00')]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	144 while pos < len(data) - 1 and pos != -1:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	145 positions.append(pos + 1)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	146 nexts = data[pos + 1:data.find('\x00', pos + 1)]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	147 if nexts < prev:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	148 raise ValueError("Manifest lines not in sorted order.")
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	149 prev = nexts
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	150 pos = data.find("\n", pos + 1)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	151 return positions
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	152
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	153 def _get(self, index):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	154 # get the position encoded in pos:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	155 # positive number is an index in 'data'
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	156 # negative number is in extrapieces
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	157 pos = self.positions[index]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	158 if pos >= 0:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	159 return self.data, pos
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	160 return self.extradata[-pos - 1], -1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	161
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	162 def _getkey(self, pos):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	163 if pos >= 0:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	164 return self.data[pos:self.data.find('\x00', pos + 1)]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	165 return self.extradata[-pos - 1][0]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	166
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	167 def bsearch(self, key):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	168 first = 0
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	169 last = len(self.positions) - 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	170
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	171 while first <= last:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	172 midpoint = (first + last)//2
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	173 nextpos = self.positions[midpoint]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	174 candidate = self._getkey(nextpos)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	175 r = _cmp(key, candidate)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	176 if r == 0:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	177 return midpoint
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	178 else:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	179 if r < 0:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	180 last = midpoint - 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	181 else:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	182 first = midpoint + 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	183 return -1
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	184
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	185 def bsearch2(self, key):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	186 # same as the above, but will always return the position
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	187 # done for performance reasons
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	188 first = 0
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	189 last = len(self.positions) - 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	190
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	191 while first <= last:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	192 midpoint = (first + last)//2
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	193 nextpos = self.positions[midpoint]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	194 candidate = self._getkey(nextpos)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	195 r = _cmp(key, candidate)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	196 if r == 0:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	197 return (midpoint, True)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	198 else:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	199 if r < 0:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	200 last = midpoint - 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	201 else:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	202 first = midpoint + 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	203 return (first, False)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	204
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	205 def __contains__(self, key):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	206 return self.bsearch(key) != -1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	207
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	208 def _getflags(self, data, needle, pos):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	209 start = pos + 41
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	210 end = data.find("\n", start)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	211 if end == -1:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	212 end = len(data) - 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	213 if start == end:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	214 return ''
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	215 return self.data[start:end]
24297 0178f500d61e lazymanifest: fix pure hg iterkeys() Martin von Zweigbergk <martinvonz@google.com> parents: 24295 diff changeset	216
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	217 def __getitem__(self, key):
31376 ef50b491c17d manifest: ensure paths are bytes (not str) in pure parser Augie Fackler <augie@google.com> parents: 31375 diff changeset	218 if not isinstance(key, bytes):
ef50b491c17d manifest: ensure paths are bytes (not str) in pure parser Augie Fackler <augie@google.com> parents: 31375 diff changeset	219 raise TypeError("getitem: manifest keys must be a bytes.")
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	220 needle = self.bsearch(key)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	221 if needle == -1:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	222 raise KeyError
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	223 data, pos = self._get(needle)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	224 if pos == -1:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	225 return (data[1], data[2])
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	226 zeropos = data.find('\x00', pos)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	227 assert 0 <= needle <= len(self.positions)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	228 assert len(self.extrainfo) == len(self.positions)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	229 hashval = unhexlify(data, self.extrainfo[needle], zeropos + 1, 40)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	230 flags = self._getflags(data, needle, zeropos)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	231 return (hashval, flags)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	232
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	233 def __delitem__(self, key):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	234 needle, found = self.bsearch2(key)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	235 if not found:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	236 raise KeyError
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	237 cur = self.positions[needle]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	238 self.positions = self.positions[:needle] + self.positions[needle + 1:]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	239 self.extrainfo = self.extrainfo[:needle] + self.extrainfo[needle + 1:]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	240 if cur >= 0:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	241 self.data = self.data[:cur] + '\x00' + self.data[cur + 1:]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	242
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	243 def __setitem__(self, key, value):
31537 326bca5477d0 manifest: refer to bytestrings as bytes, not str Augie Fackler <augie@google.com> parents: 31536 diff changeset	244 if not isinstance(key, bytes):
326bca5477d0 manifest: refer to bytestrings as bytes, not str Augie Fackler <augie@google.com> parents: 31536 diff changeset	245 raise TypeError("setitem: manifest keys must be a byte string.")
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	246 if not isinstance(value, tuple) or len(value) != 2:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	247 raise TypeError("Manifest values must be a tuple of (node, flags).")
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	248 hashval = value[0]
31537 326bca5477d0 manifest: refer to bytestrings as bytes, not str Augie Fackler <augie@google.com> parents: 31536 diff changeset	249 if not isinstance(hashval, bytes) or not 20 <= len(hashval) <= 22:
326bca5477d0 manifest: refer to bytestrings as bytes, not str Augie Fackler <augie@google.com> parents: 31536 diff changeset	250 raise TypeError("node must be a 20-byte byte string")
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	251 flags = value[1]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	252 if len(hashval) == 22:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	253 hashval = hashval[:-1]
31537 326bca5477d0 manifest: refer to bytestrings as bytes, not str Augie Fackler <augie@google.com> parents: 31536 diff changeset	254 if not isinstance(flags, bytes) or len(flags) > 1:
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	255 raise TypeError("flags must a 0 or 1 byte string, got %r", flags)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	256 needle, found = self.bsearch2(key)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	257 if found:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	258 # put the item
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	259 pos = self.positions[needle]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	260 if pos < 0:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	261 self.extradata[-pos - 1] = (key, hashval, value[1])
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	262 else:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	263 # just don't bother
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	264 self.extradata.append((key, hashval, value[1]))
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	265 self.positions[needle] = -len(self.extradata)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	266 else:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	267 # not found, put it in with extra positions
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	268 self.extradata.append((key, hashval, value[1]))
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	269 self.positions = (self.positions[:needle] + [-len(self.extradata)]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	270 + self.positions[needle:])
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	271 self.extrainfo = (self.extrainfo[:needle] + [0] +
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	272 self.extrainfo[needle:])
24298 49cd847fd69a lazymanifest: make __iter__ generate filenames, not 3-tuples Martin von Zweigbergk <martinvonz@google.com> parents: 24297 diff changeset	273
2831 0b50a580be36 Add manifestflags class Matt Mackall <mpm@selenic.com> parents: 2470 diff changeset	274 def copy(self):
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	275 # XXX call _compact like in C?
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	276 return _lazymanifest(self.data, self.positions, self.extrainfo,
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	277 self.extradata)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	278
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	279 def _compact(self):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	280 # hopefully not called TOO often
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	281 if len(self.extradata) == 0:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	282 return
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	283 l = []
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	284 last_cut = 0
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	285 i = 0
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	286 offset = 0
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	287 self.extrainfo = [0] * len(self.positions)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	288 while i < len(self.positions):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	289 if self.positions[i] >= 0:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	290 cur = self.positions[i]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	291 last_cut = cur
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	292 while True:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	293 self.positions[i] = offset
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	294 i += 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	295 if i == len(self.positions) or self.positions[i] < 0:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	296 break
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	297 offset += self.positions[i] - cur
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	298 cur = self.positions[i]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	299 end_cut = self.data.find('\n', cur)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	300 if end_cut != -1:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	301 end_cut += 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	302 offset += end_cut - cur
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	303 l.append(self.data[last_cut:end_cut])
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	304 else:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	305 while i < len(self.positions) and self.positions[i] < 0:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	306 cur = self.positions[i]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	307 t = self.extradata[-cur - 1]
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	308 l.append(self._pack(t))
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	309 self.positions[i] = offset
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	310 if len(t[1]) > 20:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	311 self.extrainfo[i] = ord(t[1][21])
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	312 offset += len(l[-1])
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	313 i += 1
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	314 self.data = ''.join(l)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	315 self.extradata = []
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	316
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	317 def _pack(self, d):
31536 160e7ad941e9 manifest: use node.hex instead of .encode('hex') Augie Fackler <augie@google.com> parents: 31483 diff changeset	318 return d[0] + '\x00' + hex(d[1][:20]) + d[2] + '\n'
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	319
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	320 def text(self):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	321 self._compact()
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	322 return self.data
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	323
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	324 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	325 '''Finds changes between the current manifest and m2.'''
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	326 # 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	327 diff = {}
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	328
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	329 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	330 if fn not in m2:
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	331 diff[fn] = (e1, flags), (None, '')
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	332 else:
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	333 e2 = m2[fn]
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	334 if (e1, flags) != e2:
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	335 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	336 elif clean:
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	337 diff[fn] = None
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	338
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	339 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	340 if fn not in self:
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	341 diff[fn] = (None, ''), (e2, flags)
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	342
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	343 return diff
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	344
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	345 def iterentries(self):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	346 return lazymanifestiterentries(self)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	347
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	348 def iterkeys(self):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	349 return lazymanifestiter(self)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	350
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	351 def __iter__(self):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	352 return lazymanifestiter(self)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	353
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	354 def __len__(self):
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	355 return len(self.positions)
d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	356
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	357 def filtercopy(self, filterfn):
30042 d24e03da24b5 lazymanifest: write a more efficient, pypy friendly version of lazymanifest Maciej Fijalkowski <fijall@gmail.com> parents: 30002 diff changeset	358 # XXX should be optimized
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	359 c = _lazymanifest('')
24298 49cd847fd69a lazymanifest: make __iter__ generate filenames, not 3-tuples Martin von Zweigbergk <martinvonz@google.com> parents: 24297 diff changeset	360 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	361 if filterfn(f):
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	362 c[f] = n, fl
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	363 return c
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	364
24226 b992769dd1be manifest: use custom C implementation of lazymanifest Augie Fackler <augie@google.com> parents: 24225 diff changeset	365 try:
b992769dd1be manifest: use custom C implementation of lazymanifest Augie Fackler <augie@google.com> parents: 24225 diff changeset	366 _lazymanifest = parsers.lazymanifest
b992769dd1be manifest: use custom C implementation of lazymanifest Augie Fackler <augie@google.com> parents: 24225 diff changeset	367 except AttributeError:
b992769dd1be manifest: use custom C implementation of lazymanifest Augie Fackler <augie@google.com> parents: 24225 diff changeset	368 pass
b992769dd1be manifest: use custom C implementation of lazymanifest Augie Fackler <augie@google.com> parents: 24225 diff changeset	369
38532 c82ea938efbb repository: define manifest interfaces Gregory Szorc <gregory.szorc@gmail.com> parents: 38514 diff changeset	370 @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	371 class manifestdict(object):
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	372 def __init__(self, data=''):
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	373 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	374
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	375 def __getitem__(self, key):
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	376 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	377
24277 22d560fe1516 manifest: don't let find() look inside manifestdict Martin von Zweigbergk <martinvonz@google.com> parents: 24226 diff changeset	378 def find(self, key):
22d560fe1516 manifest: don't let find() look inside manifestdict Martin von Zweigbergk <martinvonz@google.com> parents: 24226 diff changeset	379 return self._lm[key]
22d560fe1516 manifest: don't let find() look inside manifestdict Martin von Zweigbergk <martinvonz@google.com> parents: 24226 diff changeset	380
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	381 def __len__(self):
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	382 return len(self._lm)
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	383
30341 b19291e5d506 manifest: add __nonzero__ method Durham Goode <durham@fb.com> parents: 30309 diff changeset	384 def __nonzero__(self):
b19291e5d506 manifest: add __nonzero__ method Durham Goode <durham@fb.com> parents: 30309 diff changeset	385 # nonzero is covered by the __len__ function, but implementing it here
b19291e5d506 manifest: add __nonzero__ method Durham Goode <durham@fb.com> parents: 30309 diff changeset	386 # makes it easier for extensions to override.
b19291e5d506 manifest: add __nonzero__ method Durham Goode <durham@fb.com> parents: 30309 diff changeset	387 return len(self._lm) != 0
b19291e5d506 manifest: add __nonzero__ method Durham Goode <durham@fb.com> parents: 30309 diff changeset	388
31483 413b44003462 py3: add __bool__ to every class defining __nonzero__ Gregory Szorc <gregory.szorc@gmail.com> parents: 31376 diff changeset	389 __bool__ = __nonzero__
413b44003462 py3: add __bool__ to every class defining __nonzero__ Gregory Szorc <gregory.szorc@gmail.com> parents: 31376 diff changeset	390
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	391 def __setitem__(self, key, node):
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	392 self._lm[key] = node, self.flags(key, '')
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	393
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	394 def __contains__(self, key):
34352 05167447f90d py3: return False early while checking whether None is a key in lazymanifest Pulkit Goyal <7895pulkit@gmail.com> parents: 34303 diff changeset	395 if key is None:
05167447f90d py3: return False early while checking whether None is a key in lazymanifest Pulkit Goyal <7895pulkit@gmail.com> parents: 34303 diff changeset	396 return False
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	397 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	398
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	399 def __delitem__(self, key):
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	400 del self._lm[key]
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	401
24295 2b7ab29627fd lazymanifest: add iterkeys() method Martin von Zweigbergk <martinvonz@google.com> parents: 24292 diff changeset	402 def __iter__(self):
24298 49cd847fd69a lazymanifest: make __iter__ generate filenames, not 3-tuples Martin von Zweigbergk <martinvonz@google.com> parents: 24297 diff changeset	403 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	404
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	405 def iterkeys(self):
24295 2b7ab29627fd lazymanifest: add iterkeys() method Martin von Zweigbergk <martinvonz@google.com> parents: 24292 diff changeset	406 return self._lm.iterkeys()
2b7ab29627fd lazymanifest: add iterkeys() method Martin von Zweigbergk <martinvonz@google.com> parents: 24292 diff changeset	407
2b7ab29627fd lazymanifest: add iterkeys() method Martin von Zweigbergk <martinvonz@google.com> parents: 24292 diff changeset	408 def keys(self):
2b7ab29627fd lazymanifest: add iterkeys() method Martin von Zweigbergk <martinvonz@google.com> parents: 24292 diff changeset	409 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	410
31265 959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	411 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	412 '''Set of files in this manifest that are not in the other'''
31265 959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	413 if match:
959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	414 m1 = self.matches(match)
959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	415 m2 = m2.matches(match)
959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	416 return m1.filesnotin(m2)
29056 e2178f7d17c0 manifest: improve filesnotin performance by using lazymanifest diff Tony Tung <tonytung@merly.org> parents: 28240 diff changeset	417 diff = self.diff(m2)
e2178f7d17c0 manifest: improve filesnotin performance by using lazymanifest diff Tony Tung <tonytung@merly.org> parents: 28240 diff changeset	418 files = set(filepath
e2178f7d17c0 manifest: improve filesnotin performance by using lazymanifest diff Tony Tung <tonytung@merly.org> parents: 28240 diff changeset	419 for filepath, hashflags in diff.iteritems()
e2178f7d17c0 manifest: improve filesnotin performance by using lazymanifest diff Tony Tung <tonytung@merly.org> parents: 28240 diff changeset	420 if hashflags[1][0] is None)
24184 cd66080ef6d4 copies: move code into new manifestdict.filesnotin() method Martin von Zweigbergk <martinvonz@google.com> parents: 24147 diff changeset	421 return files
cd66080ef6d4 copies: move code into new manifestdict.filesnotin() method Martin von Zweigbergk <martinvonz@google.com> parents: 24147 diff changeset	422
24322 f263814c72ac manifest: add dirs() to manifestdict Drew Gottlieb <drgott@google.com> parents: 24298 diff changeset	423 @propertycache
f263814c72ac manifest: add dirs() to manifestdict Drew Gottlieb <drgott@google.com> parents: 24298 diff changeset	424 def _dirs(self):
24635 21e1ece30f8c util: move dirs() and finddirs() from scmutil to util Drew Gottlieb <drgott@google.com> parents: 24600 diff changeset	425 return util.dirs(self)
24322 f263814c72ac manifest: add dirs() to manifestdict Drew Gottlieb <drgott@google.com> parents: 24298 diff changeset	426
f263814c72ac manifest: add dirs() to manifestdict Drew Gottlieb <drgott@google.com> parents: 24298 diff changeset	427 def dirs(self):
f263814c72ac manifest: add dirs() to manifestdict Drew Gottlieb <drgott@google.com> parents: 24298 diff changeset	428 return self._dirs
f263814c72ac manifest: add dirs() to manifestdict Drew Gottlieb <drgott@google.com> parents: 24298 diff changeset	429
24324 149cc171e4a0 manifest: add manifestdict.hasdir() method Drew Gottlieb <drgott@google.com> parents: 24322 diff changeset	430 def hasdir(self, dir):
149cc171e4a0 manifest: add manifestdict.hasdir() method Drew Gottlieb <drgott@google.com> parents: 24322 diff changeset	431 return dir in self._dirs
149cc171e4a0 manifest: add manifestdict.hasdir() method Drew Gottlieb <drgott@google.com> parents: 24322 diff changeset	432
24685 b3d78d82d84c manifestdict: extract condition for _intersectfiles() and use for walk() Martin von Zweigbergk <martinvonz@google.com> parents: 24684 diff changeset	433 def _filesfastpath(self, match):
b3d78d82d84c manifestdict: extract condition for _intersectfiles() and use for walk() Martin von Zweigbergk <martinvonz@google.com> parents: 24684 diff changeset	434 '''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	435 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	436 files = match.files()
b3d78d82d84c manifestdict: extract condition for _intersectfiles() and use for walk() Martin von Zweigbergk <martinvonz@google.com> parents: 24684 diff changeset	437 return (len(files) < 100 and (match.isexact() or
25276 c436ba9d6ac0 manifest: use match.prefix() instead of 'not match.anypats()' Martin von Zweigbergk <martinvonz@google.com> parents: 25222 diff changeset	438 (match.prefix() and all(fn in self for fn in files))))
24685 b3d78d82d84c manifestdict: extract condition for _intersectfiles() and use for walk() Martin von Zweigbergk <martinvonz@google.com> parents: 24684 diff changeset	439
24646 5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	440 def walk(self, match):
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	441 '''Generates matching file names.
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	442
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	443 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	444 an entirely new manifest.
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	445
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	446 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	447 '''
24683 4eaea0ed8dc1 manifest.walk: special-case match.always() for speed Martin von Zweigbergk <martinvonz@google.com> parents: 24682 diff changeset	448 if match.always():
4eaea0ed8dc1 manifest.walk: special-case match.always() for speed Martin von Zweigbergk <martinvonz@google.com> parents: 24682 diff changeset	449 for f in iter(self):
4eaea0ed8dc1 manifest.walk: special-case match.always() for speed Martin von Zweigbergk <martinvonz@google.com> parents: 24682 diff changeset	450 yield f
4eaea0ed8dc1 manifest.walk: special-case match.always() for speed Martin von Zweigbergk <martinvonz@google.com> parents: 24682 diff changeset	451 return
4eaea0ed8dc1 manifest.walk: special-case match.always() for speed Martin von Zweigbergk <martinvonz@google.com> parents: 24682 diff changeset	452
24646 5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	453 fset = set(match.files())
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	454
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	455 # 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	456 if self._filesfastpath(match):
24667 19c5b0913960 manifest.walk: join nested if-conditions Martin von Zweigbergk <martinvonz@google.com> parents: 24666 diff changeset	457 for fn in sorted(fset):
19c5b0913960 manifest.walk: join nested if-conditions Martin von Zweigbergk <martinvonz@google.com> parents: 24666 diff changeset	458 yield fn
24682 aef3d1469773 manifest.walk: use return instead of StopIteration in generator Martin von Zweigbergk <martinvonz@google.com> parents: 24670 diff changeset	459 return
24646 5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	460
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	461 for fn in self:
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	462 if fn in fset:
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	463 # specified pattern is the exact name
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	464 fset.remove(fn)
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	465 if match(fn):
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	466 yield fn
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	467
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	468 # for dirstate.walk, files=['.'] means "walk the whole tree".
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	469 # follow that here, too
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	470 fset.discard('.')
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	471
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	472 for fn in sorted(fset):
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	473 if not self.hasdir(fn):
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	474 match.bad(fn, None)
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	475
23305 0cc283f44655 manifest: add matches() method Martin von Zweigbergk <martinvonz@google.com> parents: 22966 diff changeset	476 def matches(self, match):
0cc283f44655 manifest: add matches() method Martin von Zweigbergk <martinvonz@google.com> parents: 22966 diff changeset	477 '''generate a new manifest filtered by the match argument'''
0cc283f44655 manifest: add matches() method Martin von Zweigbergk <martinvonz@google.com> parents: 22966 diff changeset	478 if match.always():
0cc283f44655 manifest: add matches() method Martin von Zweigbergk <martinvonz@google.com> parents: 22966 diff changeset	479 return self.copy()
0cc283f44655 manifest: add matches() method Martin von Zweigbergk <martinvonz@google.com> parents: 22966 diff changeset	480
24685 b3d78d82d84c manifestdict: extract condition for _intersectfiles() and use for walk() Martin von Zweigbergk <martinvonz@google.com> parents: 24684 diff changeset	481 if self._filesfastpath(match):
24666 3092885b5b32 manifestdict: inline _intersectfiles() Martin von Zweigbergk <martinvonz@google.com> parents: 24665 diff changeset	482 m = manifestdict()
3092885b5b32 manifestdict: inline _intersectfiles() Martin von Zweigbergk <martinvonz@google.com> parents: 24665 diff changeset	483 lm = self._lm
3092885b5b32 manifestdict: inline _intersectfiles() Martin von Zweigbergk <martinvonz@google.com> parents: 24665 diff changeset	484 for fn in match.files():
3092885b5b32 manifestdict: inline _intersectfiles() Martin von Zweigbergk <martinvonz@google.com> parents: 24665 diff changeset	485 if fn in lm:
3092885b5b32 manifestdict: inline _intersectfiles() Martin von Zweigbergk <martinvonz@google.com> parents: 24665 diff changeset	486 m._lm[fn] = lm[fn]
3092885b5b32 manifestdict: inline _intersectfiles() Martin von Zweigbergk <martinvonz@google.com> parents: 24665 diff changeset	487 return m
23305 0cc283f44655 manifest: add matches() method Martin von Zweigbergk <martinvonz@google.com> parents: 22966 diff changeset	488
24700 32b268cbff00 manifestdict: drop empty-string argument when creating empty manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24685 diff changeset	489 m = manifestdict()
24664 ea4a7c8909ae manifestdict.matches: avoid name 'lm' for a not-lazymanifest Martin von Zweigbergk <martinvonz@google.com> parents: 24647 diff changeset	490 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	491 return m
23305 0cc283f44655 manifest: add matches() method Martin von Zweigbergk <martinvonz@google.com> parents: 22966 diff changeset	492
31265 959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	493 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	494 '''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	495
829f640b5540 manifest: add optional recording of clean entries to diff Augie Fackler <augie@google.com> parents: 23602 diff changeset	496 Args:
829f640b5540 manifest: add optional recording of clean entries to diff Augie Fackler <augie@google.com> parents: 23602 diff changeset	497 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	498 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	499 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	500
829f640b5540 manifest: add optional recording of clean entries to diff Augie Fackler <augie@google.com> parents: 23602 diff changeset	501 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	502 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	503 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	504 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	505 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	506 string.
829f640b5540 manifest: add optional recording of clean entries to diff Augie Fackler <augie@google.com> parents: 23602 diff changeset	507 '''
31265 959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	508 if match:
959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	509 m1 = self.matches(match)
959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	510 m2 = m2.matches(match)
959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	511 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	512 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	513
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	514 def setflag(self, key, flag):
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	515 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	516
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	517 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	518 try:
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	519 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	520 except KeyError:
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	521 return default
22965 b697fa74b475 manifest: for diff(), only iterate over files, not flags Martin von Zweigbergk <martinvonz@gmail.com> parents: 22964 diff changeset	522
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	523 def flags(self, key, default=''):
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	524 try:
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	525 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	526 except KeyError:
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	527 return default
22965 b697fa74b475 manifest: for diff(), only iterate over files, not flags Martin von Zweigbergk <martinvonz@gmail.com> parents: 22964 diff changeset	528
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	529 def copy(self):
24700 32b268cbff00 manifestdict: drop empty-string argument when creating empty manifest Martin von Zweigbergk <martinvonz@google.com> parents: 24685 diff changeset	530 c = manifestdict()
24225 3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	531 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	532 return c
3e5c4af69808 manifest: split manifestdict into high-level and low-level logic Augie Fackler <augie@google.com> parents: 24224 diff changeset	533
32583 b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias Augie Fackler <raf@durin42.com> parents: 32569 diff changeset	534 def items(self):
24298 49cd847fd69a lazymanifest: make __iter__ generate filenames, not 3-tuples Martin von Zweigbergk <martinvonz@google.com> parents: 24297 diff changeset	535 return (x[:2] for x in self._lm.iterentries())
2831 0b50a580be36 Add manifestflags class Matt Mackall <mpm@selenic.com> parents: 2470 diff changeset	536
32583 b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias Augie Fackler <raf@durin42.com> parents: 32569 diff changeset	537 iteritems = items
b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias Augie Fackler <raf@durin42.com> parents: 32569 diff changeset	538
28203 7297e9e13a8a verify: check directory manifests Martin von Zweigbergk <martinvonz@google.com> parents: 27502 diff changeset	539 def iterentries(self):
7297e9e13a8a verify: check directory manifests Martin von Zweigbergk <martinvonz@google.com> parents: 27502 diff changeset	540 return self._lm.iterentries()
7297e9e13a8a verify: check directory manifests Martin von Zweigbergk <martinvonz@google.com> parents: 27502 diff changeset	541
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	542 def text(self):
0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	543 # most likely uses native version
0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	544 return self._lm.text()
22408 dc97e04c12ad manifest: move checkforbidden to module-level Augie Fackler <raf@durin42.com> parents: 21879 diff changeset	545
22931 48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	546 def fastdelta(self, base, changes):
31790 6bfea18df609 manifest: update comment to be about bytearray Martin von Zweigbergk <martinvonz@google.com> parents: 31655 diff changeset	547 """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	548 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	549 """
48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	550 delta = []
48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	551 dstart = None
48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	552 dend = None
48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	553 dline = [""]
48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	554 start = 0
48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	555 # zero copy representation of base as a buffer
48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	556 addbuf = util.buffer(base)
48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	557
26871 1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	558 changes = list(changes)
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	559 if len(changes) < 1000:
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	560 # 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	561 # each line and creates the deltas
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	562 for f, todelete in changes:
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	563 # 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	564 start, end = _msearch(addbuf, f, start)
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	565 if not todelete:
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	566 h, fl = self._lm[f]
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	567 l = "%s\0%s%s\n" % (f, revlog.hex(h), fl)
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	568 else:
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	569 if start == end:
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	570 # 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	571 raise AssertionError(
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	572 _("failed to remove %s from manifest") % f)
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	573 l = ""
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	574 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	575 if dend < end:
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	576 dend = end
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	577 if l:
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	578 dline.append(l)
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	579 else:
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	580 if dstart is not None:
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	581 delta.append([dstart, dend, "".join(dline)])
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	582 dstart = start
22931 48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	583 dend = end
26871 1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	584 dline = [l]
22931 48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	585
26871 1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	586 if dstart is not None:
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	587 delta.append([dstart, dend, "".join(dline)])
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	588 # 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	589 deltatext, arraytext = _addlistdelta(base, delta)
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	590 else:
1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	591 # 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	592 # diff it.
31355 2a18e9e6ca43 py3: use bytearray() instead of array('c', ...) constructions Augie Fackler <augie@google.com> parents: 31303 diff changeset	593 arraytext = bytearray(self.text())
2a18e9e6ca43 py3: use bytearray() instead of array('c', ...) constructions Augie Fackler <augie@google.com> parents: 31303 diff changeset	594 deltatext = mdiff.textdiff(
2a18e9e6ca43 py3: use bytearray() instead of array('c', ...) constructions Augie Fackler <augie@google.com> parents: 31303 diff changeset	595 util.buffer(base), util.buffer(arraytext))
26871 1cbf144fd8a1 manifest: skip fastdelta if the change is large Durham Goode <durham@fb.com> parents: 26402 diff changeset	596
22931 48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	597 return arraytext, deltatext
48c0b101a9de manifest: add fastdelta method to manifestdict Augie Fackler <raf@durin42.com> parents: 22930 diff changeset	598
22930 1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	599 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	600 '''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	601
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	602 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	603 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	604 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	605
31655 23391acfc421 py3: fix manifestdict.fastdelta() to be compatible with memoryview Yuya Nishihara <yuya@tcha.org> parents: 31537 diff changeset	606 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: 31537 diff changeset	607 s is a byte string'''
22930 1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	608 def advance(i, c):
31655 23391acfc421 py3: fix manifestdict.fastdelta() to be compatible with memoryview Yuya Nishihara <yuya@tcha.org> parents: 31537 diff changeset	609 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	610 i += 1
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	611 return i
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	612 if not s:
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	613 return (lo, lo)
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	614 lenm = len(m)
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	615 if not hi:
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	616 hi = lenm
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	617 while lo < hi:
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	618 mid = (lo + hi) // 2
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	619 start = mid
31655 23391acfc421 py3: fix manifestdict.fastdelta() to be compatible with memoryview Yuya Nishihara <yuya@tcha.org> parents: 31537 diff changeset	620 while start > 0 and m[start - 1:start] != '\n':
22930 1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	621 start -= 1
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	622 end = advance(start, '\0')
31655 23391acfc421 py3: fix manifestdict.fastdelta() to be compatible with memoryview Yuya Nishihara <yuya@tcha.org> parents: 31537 diff changeset	623 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	624 # 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	625 # this translates to the bisect lo = mid + 1
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	626 lo = advance(end + 40, '\n') + 1
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	627 else:
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	628 # 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	629 hi = start
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	630 end = advance(lo, '\0')
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	631 found = m[lo:end]
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	632 if s == found:
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	633 # 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	634 end = advance(end + 40, '\n')
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	635 return (lo, end + 1)
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	636 else:
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	637 return (lo, lo)
1acb81d10eaf manifest: move _search to module level and rename to _msearch Augie Fackler <raf@durin42.com> parents: 22929 diff changeset	638
22415 65ec6c5c0fb3 manifest: mark addlistdelta and checkforbidden as module-private Augie Fackler <raf@durin42.com> parents: 22409 diff changeset	639 def _checkforbidden(l):
22408 dc97e04c12ad manifest: move checkforbidden to module-level Augie Fackler <raf@durin42.com> parents: 21879 diff changeset	640 """Check filenames for illegal characters."""
dc97e04c12ad manifest: move checkforbidden to module-level Augie Fackler <raf@durin42.com> parents: 21879 diff changeset	641 for f in l:
dc97e04c12ad manifest: move checkforbidden to module-level Augie Fackler <raf@durin42.com> parents: 21879 diff changeset	642 if '\n' in f or '\r' in f:
dc97e04c12ad manifest: move checkforbidden to module-level Augie Fackler <raf@durin42.com> parents: 21879 diff changeset	643 raise error.RevlogError(
38340 cf59de802883 py3: remove b'' from error message of disallowed filename Yuya Nishihara <yuya@tcha.org> parents: 37374 diff changeset	644 _("'\\n' and '\\r' disallowed in filenames: %r")
cf59de802883 py3: remove b'' from error message of disallowed filename Yuya Nishihara <yuya@tcha.org> parents: 37374 diff changeset	645 % pycompat.bytestr(f))
22408 dc97e04c12ad manifest: move checkforbidden to module-level Augie Fackler <raf@durin42.com> parents: 21879 diff changeset	646
dc97e04c12ad manifest: move checkforbidden to module-level Augie Fackler <raf@durin42.com> parents: 21879 diff changeset	647
22409 8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	648 # 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	649 # 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	650 def _addlistdelta(addlist, x):
22409 8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	651 # 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	652 # than repeatedly modifying the existing one
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	653 currentposition = 0
31355 2a18e9e6ca43 py3: use bytearray() instead of array('c', ...) constructions Augie Fackler <augie@google.com> parents: 31303 diff changeset	654 newaddlist = bytearray()
22409 8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	655
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	656 for start, end, content in x:
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	657 newaddlist += addlist[currentposition:start]
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	658 if content:
31355 2a18e9e6ca43 py3: use bytearray() instead of array('c', ...) constructions Augie Fackler <augie@google.com> parents: 31303 diff changeset	659 newaddlist += bytearray(content)
22409 8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	660
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	661 currentposition = end
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	662
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	663 newaddlist += addlist[currentposition:]
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	664
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	665 deltatext = "".join(struct.pack(">lll", start, end, len(content))
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	666 + content for start, end, content in x)
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	667 return deltatext, newaddlist
8f09b785b59b manifest: move addlistdelta to module-level Augie Fackler <raf@durin42.com> parents: 22408 diff changeset	668
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	669 def _splittopdir(f):
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	670 if '/' in f:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	671 dir, subpath = f.split('/', 1)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	672 return dir + '/', subpath
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	673 else:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	674 return '', f
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	675
26402 05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	676 _noop = lambda s: None
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	677
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	678 class treemanifest(object):
24403 0e23faa1511c treemanifest: store directory path in treemanifest nodes Martin von Zweigbergk <martinvonz@google.com> parents: 24402 diff changeset	679 def __init__(self, dir='', text=''):
0e23faa1511c treemanifest: store directory path in treemanifest nodes Martin von Zweigbergk <martinvonz@google.com> parents: 24402 diff changeset	680 self._dir = dir
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	681 self._node = revlog.nullid
26402 05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	682 self._loadfunc = _noop
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	683 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	684 self._dirty = False
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	685 self._dirs = {}
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	686 # 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	687 self._files = {}
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	688 self._flags = {}
25220 f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	689 if text:
f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	690 def readsubtree(subdir, subm):
f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	691 raise AssertionError('treemanifest constructor only accepts '
f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	692 'flat manifests')
f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	693 self.parse(text, readsubtree)
f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	694 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	695
24403 0e23faa1511c treemanifest: store directory path in treemanifest nodes Martin von Zweigbergk <martinvonz@google.com> parents: 24402 diff changeset	696 def _subpath(self, path):
0e23faa1511c treemanifest: store directory path in treemanifest nodes Martin von Zweigbergk <martinvonz@google.com> parents: 24402 diff changeset	697 return self._dir + path
0e23faa1511c treemanifest: store directory path in treemanifest nodes Martin von Zweigbergk <martinvonz@google.com> parents: 24402 diff changeset	698
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	699 def __len__(self):
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	700 self._load()
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	701 size = len(self._files)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	702 for m in self._dirs.values():
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	703 size += m.__len__()
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	704 return size
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	705
36212 b42c47b8c9d4 treemanifest: add an optimized __nonzero__() Martin von Zweigbergk <martinvonz@google.com> parents: 36133 diff changeset	706 def __nonzero__(self):
b42c47b8c9d4 treemanifest: add an optimized __nonzero__() Martin von Zweigbergk <martinvonz@google.com> parents: 36133 diff changeset	707 # Faster than "__len() != 0" since it avoids loading sub-manifests
b42c47b8c9d4 treemanifest: add an optimized __nonzero__() Martin von Zweigbergk <martinvonz@google.com> parents: 36133 diff changeset	708 return not self._isempty()
b42c47b8c9d4 treemanifest: add an optimized __nonzero__() Martin von Zweigbergk <martinvonz@google.com> parents: 36133 diff changeset	709
b42c47b8c9d4 treemanifest: add an optimized __nonzero__() Martin von Zweigbergk <martinvonz@google.com> parents: 36133 diff changeset	710 __bool__ = __nonzero__
b42c47b8c9d4 treemanifest: add an optimized __nonzero__() Martin von Zweigbergk <martinvonz@google.com> parents: 36133 diff changeset	711
24551 4fdf5eac5b39 treemanifest: add treemanifest._isempty() Drew Gottlieb <drgott@google.com> parents: 24550 diff changeset	712 def _isempty(self):
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	713 self._load() # for consistency; already loaded by all callers
24551 4fdf5eac5b39 treemanifest: add treemanifest._isempty() Drew Gottlieb <drgott@google.com> parents: 24550 diff changeset	714 return (not self._files and (not self._dirs or
25151 6eb4bdad198f cleanup: use __builtins__.all instead of util.all Augie Fackler <augie@google.com> parents: 25119 diff changeset	715 all(m._isempty() for m in self._dirs.values())))
24551 4fdf5eac5b39 treemanifest: add treemanifest._isempty() Drew Gottlieb <drgott@google.com> parents: 24550 diff changeset	716
26400 6f9d9e2a661f manifest: add id(self) to treemanifest __repr__ Augie Fackler <augie@google.com> parents: 26199 diff changeset	717 def __repr__(self):
6f9d9e2a661f manifest: add id(self) to treemanifest __repr__ Augie Fackler <augie@google.com> parents: 26199 diff changeset	718 return ('<treemanifest dir=%s, node=%s, loaded=%s, dirty=%s at 0x%x>' %
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	719 (self._dir, revlog.hex(self._node),
26402 05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	720 bool(self._loadfunc is _noop),
26400 6f9d9e2a661f manifest: add id(self) to treemanifest __repr__ Augie Fackler <augie@google.com> parents: 26199 diff changeset	721 self._dirty, id(self)))
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	722
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	723 def dir(self):
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	724 '''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	725 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	726 return self._dir
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	727
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	728 def node(self):
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	729 '''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	730 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	731 '''
25220 f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	732 assert not self._dirty
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	733 return self._node
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	734
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	735 def setnode(self, node):
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	736 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	737 self._dirty = False
24403 0e23faa1511c treemanifest: store directory path in treemanifest nodes Martin von Zweigbergk <martinvonz@google.com> parents: 24402 diff changeset	738
28206 8ab91d9290ce treemanifest: implement iterentries() Martin von Zweigbergk <martinvonz@google.com> parents: 28203 diff changeset	739 def iterentries(self):
8ab91d9290ce treemanifest: implement iterentries() Martin von Zweigbergk <martinvonz@google.com> parents: 28203 diff changeset	740 self._load()
32569 aa333c1982ab manifest: use itertools.chain() instead of + for Python 3 compat Augie Fackler <raf@durin42.com> parents: 32568 diff changeset	741 for p, n in sorted(itertools.chain(self._dirs.items(),
aa333c1982ab manifest: use itertools.chain() instead of + for Python 3 compat Augie Fackler <raf@durin42.com> parents: 32568 diff changeset	742 self._files.items())):
28206 8ab91d9290ce treemanifest: implement iterentries() Martin von Zweigbergk <martinvonz@google.com> parents: 28203 diff changeset	743 if p in self._files:
8ab91d9290ce treemanifest: implement iterentries() Martin von Zweigbergk <martinvonz@google.com> parents: 28203 diff changeset	744 yield self._subpath(p), n, self._flags.get(p, '')
8ab91d9290ce treemanifest: implement iterentries() Martin von Zweigbergk <martinvonz@google.com> parents: 28203 diff changeset	745 else:
8ab91d9290ce treemanifest: implement iterentries() Martin von Zweigbergk <martinvonz@google.com> parents: 28203 diff changeset	746 for x in n.iterentries():
8ab91d9290ce treemanifest: implement iterentries() Martin von Zweigbergk <martinvonz@google.com> parents: 28203 diff changeset	747 yield x
8ab91d9290ce treemanifest: implement iterentries() Martin von Zweigbergk <martinvonz@google.com> parents: 28203 diff changeset	748
32583 b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias Augie Fackler <raf@durin42.com> parents: 32569 diff changeset	749 def items(self):
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	750 self._load()
32569 aa333c1982ab manifest: use itertools.chain() instead of + for Python 3 compat Augie Fackler <raf@durin42.com> parents: 32568 diff changeset	751 for p, n in sorted(itertools.chain(self._dirs.items(),
aa333c1982ab manifest: use itertools.chain() instead of + for Python 3 compat Augie Fackler <raf@durin42.com> parents: 32568 diff changeset	752 self._files.items())):
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	753 if p in self._files:
24403 0e23faa1511c treemanifest: store directory path in treemanifest nodes Martin von Zweigbergk <martinvonz@google.com> parents: 24402 diff changeset	754 yield self._subpath(p), n
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	755 else:
24403 0e23faa1511c treemanifest: store directory path in treemanifest nodes Martin von Zweigbergk <martinvonz@google.com> parents: 24402 diff changeset	756 for f, sn in n.iteritems():
0e23faa1511c treemanifest: store directory path in treemanifest nodes Martin von Zweigbergk <martinvonz@google.com> parents: 24402 diff changeset	757 yield f, sn
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	758
32583 b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias Augie Fackler <raf@durin42.com> parents: 32569 diff changeset	759 iteritems = items
b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias Augie Fackler <raf@durin42.com> parents: 32569 diff changeset	760
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	761 def iterkeys(self):
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	762 self._load()
32569 aa333c1982ab manifest: use itertools.chain() instead of + for Python 3 compat Augie Fackler <raf@durin42.com> parents: 32568 diff changeset	763 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	764 if p in self._files:
24403 0e23faa1511c treemanifest: store directory path in treemanifest nodes Martin von Zweigbergk <martinvonz@google.com> parents: 24402 diff changeset	765 yield self._subpath(p)
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	766 else:
35586 fbf1a5d680ea py3: don't use dict.iterkeys() Pulkit Goyal <7895pulkit@gmail.com> parents: 34352 diff changeset	767 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	768 yield f
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	769
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	770 def keys(self):
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	771 return list(self.iterkeys())
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	772
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	773 def __iter__(self):
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	774 return self.iterkeys()
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	775
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	776 def __contains__(self, f):
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	777 if f is None:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	778 return False
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	779 self._load()
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	780 dir, subpath = _splittopdir(f)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	781 if dir:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	782 if dir not in self._dirs:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	783 return False
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	784 return self._dirs[dir].__contains__(subpath)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	785 else:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	786 return f in self._files
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	787
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	788 def get(self, f, default=None):
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	789 self._load()
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	790 dir, subpath = _splittopdir(f)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	791 if dir:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	792 if dir not in self._dirs:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	793 return default
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	794 return self._dirs[dir].get(subpath, default)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	795 else:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	796 return self._files.get(f, default)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	797
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	798 def __getitem__(self, f):
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	799 self._load()
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	800 dir, subpath = _splittopdir(f)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	801 if dir:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	802 return self._dirs[dir].__getitem__(subpath)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	803 else:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	804 return self._files[f]
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	805
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	806 def flags(self, f):
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	807 self._load()
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	808 dir, subpath = _splittopdir(f)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	809 if dir:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	810 if dir not in self._dirs:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	811 return ''
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	812 return self._dirs[dir].flags(subpath)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	813 else:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	814 if f in self._dirs:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	815 return ''
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	816 return self._flags.get(f, '')
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	817
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	818 def find(self, f):
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	819 self._load()
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	820 dir, subpath = _splittopdir(f)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	821 if dir:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	822 return self._dirs[dir].find(subpath)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	823 else:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	824 return self._files[f], self._flags.get(f, '')
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	825
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	826 def __delitem__(self, f):
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	827 self._load()
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	828 dir, subpath = _splittopdir(f)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	829 if dir:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	830 self._dirs[dir].__delitem__(subpath)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	831 # If the directory is now empty, remove it
24551 4fdf5eac5b39 treemanifest: add treemanifest._isempty() Drew Gottlieb <drgott@google.com> parents: 24550 diff changeset	832 if self._dirs[dir]._isempty():
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	833 del self._dirs[dir]
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	834 else:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	835 del self._files[f]
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	836 if f in self._flags:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	837 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	838 self._dirty = True
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	839
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	840 def __setitem__(self, f, n):
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	841 assert n is not None
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	842 self._load()
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	843 dir, subpath = _splittopdir(f)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	844 if dir:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	845 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	846 self._dirs[dir] = treemanifest(self._subpath(dir))
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	847 self._dirs[dir].__setitem__(subpath, n)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	848 else:
24467 bfb754050ccd treemanifest: drop 22nd byte for consistency with manifestdict Martin von Zweigbergk <martinvonz@google.com> parents: 24448 diff changeset	849 self._files[f] = n[:21] # to match manifestdict's behavior
25220 f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	850 self._dirty = True
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	851
26402 05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	852 def _load(self):
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	853 if self._loadfunc is not _noop:
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	854 lf, self._loadfunc = self._loadfunc, _noop
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	855 lf(self)
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	856 elif self._copyfunc is not _noop:
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	857 cf, self._copyfunc = self._copyfunc, _noop
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	858 cf(self)
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	859
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	860 def setflag(self, f, flags):
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	861 """Set the flags (symlink, executable) for path f."""
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	862 self._load()
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	863 dir, subpath = _splittopdir(f)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	864 if dir:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	865 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	866 self._dirs[dir] = treemanifest(self._subpath(dir))
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	867 self._dirs[dir].setflag(subpath, flags)
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	868 else:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	869 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	870 self._dirty = True
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	871
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	872 def copy(self):
24403 0e23faa1511c treemanifest: store directory path in treemanifest nodes Martin von Zweigbergk <martinvonz@google.com> parents: 24402 diff changeset	873 copy = treemanifest(self._dir)
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	874 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	875 copy._dirty = self._dirty
26402 05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	876 if self._copyfunc is _noop:
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	877 def _copyfunc(s):
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	878 self._load()
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	879 for d in self._dirs:
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	880 s._dirs[d] = self._dirs[d].copy()
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	881 s._files = dict.copy(self._files)
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	882 s._flags = dict.copy(self._flags)
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	883 if self._loadfunc is _noop:
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	884 _copyfunc(copy)
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	885 else:
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	886 copy._copyfunc = _copyfunc
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	887 else:
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	888 copy._copyfunc = self._copyfunc
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	889 return copy
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	890
31265 959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	891 def filesnotin(self, m2, match=None):
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	892 '''Set of files in this manifest that are not in the other'''
31265 959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	893 if match:
959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	894 m1 = self.matches(match)
959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	895 m2 = m2.matches(match)
959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	896 return m1.filesnotin(m2)
959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	897
24405 cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	898 files = set()
cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	899 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	900 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	901 return
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	902 t1._load()
0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	903 t2._load()
24405 cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	904 for d, m1 in t1._dirs.iteritems():
cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	905 if d in t2._dirs:
cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	906 m2 = t2._dirs[d]
cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	907 _filesnotin(m1, m2)
cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	908 else:
cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	909 files.update(m1.iterkeys())
cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	910
36333 413c179cf7d5 manifest: correct the one use of iterkeys() on a dict Augie Fackler <augie@google.com> parents: 36212 diff changeset	911 for fn in t1._files:
24405 cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	912 if fn not in t2._files:
cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	913 files.add(t1._subpath(fn))
cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	914
cbe9d50d9e65 treemanifest: make filesnotin() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24404 diff changeset	915 _filesnotin(self, m2)
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	916 return files
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	917
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	918 @propertycache
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	919 def _alldirs(self):
24635 21e1ece30f8c util: move dirs() and finddirs() from scmutil to util Drew Gottlieb <drgott@google.com> parents: 24600 diff changeset	920 return util.dirs(self)
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	921
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	922 def dirs(self):
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	923 return self._alldirs
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	924
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	925 def hasdir(self, dir):
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	926 self._load()
24406 1297480ed347 treemanifest: make hasdir() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24405 diff changeset	927 topdir, subdir = _splittopdir(dir)
1297480ed347 treemanifest: make hasdir() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24405 diff changeset	928 if topdir:
1297480ed347 treemanifest: make hasdir() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24405 diff changeset	929 if topdir in self._dirs:
1297480ed347 treemanifest: make hasdir() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24405 diff changeset	930 return self._dirs[topdir].hasdir(subdir)
1297480ed347 treemanifest: make hasdir() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24405 diff changeset	931 return False
1297480ed347 treemanifest: make hasdir() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24405 diff changeset	932 return (dir + '/') in self._dirs
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	933
24646 5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	934 def walk(self, match):
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	935 '''Generates matching file names.
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	936
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	937 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	938 an entirely new manifest.
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	939
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	940 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	941 '''
24683 4eaea0ed8dc1 manifest.walk: special-case match.always() for speed Martin von Zweigbergk <martinvonz@google.com> parents: 24682 diff changeset	942 if match.always():
4eaea0ed8dc1 manifest.walk: special-case match.always() for speed Martin von Zweigbergk <martinvonz@google.com> parents: 24682 diff changeset	943 for f in iter(self):
4eaea0ed8dc1 manifest.walk: special-case match.always() for speed Martin von Zweigbergk <martinvonz@google.com> parents: 24682 diff changeset	944 yield f
4eaea0ed8dc1 manifest.walk: special-case match.always() for speed Martin von Zweigbergk <martinvonz@google.com> parents: 24682 diff changeset	945 return
4eaea0ed8dc1 manifest.walk: special-case match.always() for speed Martin von Zweigbergk <martinvonz@google.com> parents: 24682 diff changeset	946
24646 5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	947 fset = set(match.files())
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	948
24647 fb446c57f8f9 treemanifest: refactor treemanifest.walk() Drew Gottlieb <drgott@google.com> parents: 24646 diff changeset	949 for fn in self._walk(match):
24646 5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	950 if fn in fset:
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	951 # specified pattern is the exact name
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	952 fset.remove(fn)
24647 fb446c57f8f9 treemanifest: refactor treemanifest.walk() Drew Gottlieb <drgott@google.com> parents: 24646 diff changeset	953 yield fn
24646 5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	954
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	955 # for dirstate.walk, files=['.'] means "walk the whole tree".
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	956 # follow that here, too
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	957 fset.discard('.')
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	958
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	959 for fn in sorted(fset):
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	960 if not self.hasdir(fn):
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	961 match.bad(fn, None)
5693c834bcb4 manifest: move changectx.walk() to manifests Drew Gottlieb <drgott@google.com> parents: 24636 diff changeset	962
25188 2773540c3650 match: remove unnecessary optimization where visitdir() returns 'all' Drew Gottlieb <drgott@google.com> parents: 25185 diff changeset	963 def _walk(self, match):
2773540c3650 match: remove unnecessary optimization where visitdir() returns 'all' Drew Gottlieb <drgott@google.com> parents: 25185 diff changeset	964 '''Recursively generates matching file names for walk().'''
2773540c3650 match: remove unnecessary optimization where visitdir() returns 'all' Drew Gottlieb <drgott@google.com> parents: 25185 diff changeset	965 if not match.visitdir(self._dir[:-1] or '.'):
2773540c3650 match: remove unnecessary optimization where visitdir() returns 'all' Drew Gottlieb <drgott@google.com> parents: 25185 diff changeset	966 return
24647 fb446c57f8f9 treemanifest: refactor treemanifest.walk() Drew Gottlieb <drgott@google.com> parents: 24646 diff changeset	967
fb446c57f8f9 treemanifest: refactor treemanifest.walk() Drew Gottlieb <drgott@google.com> parents: 24646 diff changeset	968 # 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	969 self._load()
36334 5245bac09e6a manifest: use list(dict) instead of dict.keys() to get a list of keys Augie Fackler <augie@google.com> parents: 36333 diff changeset	970 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	971 if p in self._files:
fb446c57f8f9 treemanifest: refactor treemanifest.walk() Drew Gottlieb <drgott@google.com> parents: 24646 diff changeset	972 fullp = self._subpath(p)
fb446c57f8f9 treemanifest: refactor treemanifest.walk() Drew Gottlieb <drgott@google.com> parents: 24646 diff changeset	973 if match(fullp):
fb446c57f8f9 treemanifest: refactor treemanifest.walk() Drew Gottlieb <drgott@google.com> parents: 24646 diff changeset	974 yield fullp
fb446c57f8f9 treemanifest: refactor treemanifest.walk() Drew Gottlieb <drgott@google.com> parents: 24646 diff changeset	975 else:
25188 2773540c3650 match: remove unnecessary optimization where visitdir() returns 'all' Drew Gottlieb <drgott@google.com> parents: 25185 diff changeset	976 for f in self._dirs[p]._walk(match):
24647 fb446c57f8f9 treemanifest: refactor treemanifest.walk() Drew Gottlieb <drgott@google.com> parents: 24646 diff changeset	977 yield f
fb446c57f8f9 treemanifest: refactor treemanifest.walk() Drew Gottlieb <drgott@google.com> parents: 24646 diff changeset	978
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	979 def matches(self, match):
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	980 '''generate a new manifest filtered by the match argument'''
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	981 if match.always():
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	982 return self.copy()
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	983
24552 a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	984 return self._matches(match)
a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	985
25188 2773540c3650 match: remove unnecessary optimization where visitdir() returns 'all' Drew Gottlieb <drgott@google.com> parents: 25185 diff changeset	986 def _matches(self, match):
24552 a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	987 '''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	988 '''
27343 c59647c6694d treemanifest: don't iterate entire matching submanifests on match() Martin von Zweigbergk <martinvonz@google.com> parents: 27271 diff changeset	989
c59647c6694d treemanifest: don't iterate entire matching submanifests on match() Martin von Zweigbergk <martinvonz@google.com> parents: 27271 diff changeset	990 visit = match.visitdir(self._dir[:-1] or '.')
c59647c6694d treemanifest: don't iterate entire matching submanifests on match() Martin von Zweigbergk <martinvonz@google.com> parents: 27271 diff changeset	991 if visit == 'all':
c59647c6694d treemanifest: don't iterate entire matching submanifests on match() Martin von Zweigbergk <martinvonz@google.com> parents: 27271 diff changeset	992 return self.copy()
24552 a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	993 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	994 if not visit:
25188 2773540c3650 match: remove unnecessary optimization where visitdir() returns 'all' Drew Gottlieb <drgott@google.com> parents: 25185 diff changeset	995 return ret
24552 a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	996
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	997 self._load()
24552 a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	998 for fn in self._files:
a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	999 fullp = self._subpath(fn)
a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1000 if not match(fullp):
a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1001 continue
a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1002 ret._files[fn] = self._files[fn]
a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1003 if fn in self._flags:
a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1004 ret._flags[fn] = self._flags[fn]
a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1005
a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1006 for dir, subm in self._dirs.iteritems():
25188 2773540c3650 match: remove unnecessary optimization where visitdir() returns 'all' Drew Gottlieb <drgott@google.com> parents: 25185 diff changeset	1007 m = subm._matches(match)
24552 a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1008 if not m._isempty():
a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1009 ret._dirs[dir] = m
a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1010
25220 f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1011 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	1012 ret._dirty = True
24552 a2292da6d821 treemanifest: make treemanifest.matches() faster Drew Gottlieb <drgott@google.com> parents: 24551 diff changeset	1013 return ret
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1014
31265 959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	1015 def diff(self, m2, match=None, clean=False):
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1016 '''Finds changes between the current manifest and m2.
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1017
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1018 Args:
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1019 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	1020 clean: if true, include files unchanged between these manifests
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1021 with a None value in the returned dictionary.
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1022
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1023 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	1024 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	1025 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	1026 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	1027 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	1028 string.
e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1029 '''
31265 959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	1030 if match:
959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	1031 m1 = self.matches(match)
959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	1032 m2 = m2.matches(match)
959ebff3505a manifest: add match argument to diff and filesnotin Durham Goode <durham@fb.com> parents: 31163 diff changeset	1033 return m1.diff(m2, clean=clean)
24404 96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1034 result = {}
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1035 emptytree = treemanifest()
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1036 def _diff(t1, t2):
25220 f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1037 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	1038 return
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1039 t1._load()
0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1040 t2._load()
24404 96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1041 for d, m1 in t1._dirs.iteritems():
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1042 m2 = t2._dirs.get(d, emptytree)
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1043 _diff(m1, m2)
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1044
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1045 for d, m2 in t2._dirs.iteritems():
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1046 if d not in t1._dirs:
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1047 _diff(emptytree, m2)
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1048
24404 96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1049 for fn, n1 in t1._files.iteritems():
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1050 fl1 = t1._flags.get(fn, '')
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1051 n2 = t2._files.get(fn, None)
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1052 fl2 = t2._flags.get(fn, '')
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1053 if n1 != n2 or fl1 != fl2:
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1054 result[t1._subpath(fn)] = ((n1, fl1), (n2, fl2))
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1055 elif clean:
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1056 result[t1._subpath(fn)] = None
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1057
24404 96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1058 for fn, n2 in t2._files.iteritems():
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1059 if fn not in t1._files:
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1060 fl2 = t2._flags.get(fn, '')
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1061 result[t2._subpath(fn)] = ((None, ''), (n2, fl2))
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1062
24404 96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1063 _diff(self, m2)
96cccf1e3257 treemanifest: make diff() faster Martin von Zweigbergk <martinvonz@google.com> parents: 24403 diff changeset	1064 return result
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1065
25221 eafa06e9edde treemanifest: speed up commit using dirty flag Martin von Zweigbergk <martinvonz@google.com> parents: 25220 diff changeset	1066 def unmodifiedsince(self, m2):
eafa06e9edde treemanifest: speed up commit using dirty flag Martin von Zweigbergk <martinvonz@google.com> parents: 25220 diff changeset	1067 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	1068
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1069 def parse(self, text, readsubtree):
24781 055b3cbe6c57 treemanifest: extract parse method from constructor Martin von Zweigbergk <martinvonz@google.com> parents: 24780 diff changeset	1070 for f, n, fl in _parse(text):
27271 2a31433a59ba manifest: use 't' for tree manifest flag Martin von Zweigbergk <martinvonz@google.com> parents: 26871 diff changeset	1071 if fl == 't':
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1072 f = f + '/'
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1073 self._dirs[f] = readsubtree(self._subpath(f), n)
25220 f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1074 elif '/' in f:
f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1075 # 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	1076 # 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	1077 # 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	1078 # to nullid).
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1079 self[f] = n
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1080 if fl:
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1081 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	1082 else:
f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1083 # 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	1084 # 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	1085 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	1086 if fl:
f0fbd88b21fb treemanifest: speed up diff by keeping track of dirty nodes Martin von Zweigbergk <martinvonz@google.com> parents: 25188 diff changeset	1087 self._flags[f] = fl
24781 055b3cbe6c57 treemanifest: extract parse method from constructor Martin von Zweigbergk <martinvonz@google.com> parents: 24780 diff changeset	1088
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	1089 def text(self):
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1090 """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	1091 self._load()
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	1092 return _text(self.iterentries())
24401 e6e023d57e94 treemanifest: create treemanifest class Martin von Zweigbergk <martinvonz@google.com> parents: 24396 diff changeset	1093
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	1094 def dirtext(self):
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1095 """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	1096 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	1097 """
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1098 self._load()
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1099 flags = self.flags
27271 2a31433a59ba manifest: use 't' for tree manifest flag Martin von Zweigbergk <martinvonz@google.com> parents: 26871 diff changeset	1100 dirs = [(d[:-1], self._dirs[d]._node, 't') for d in self._dirs]
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1101 files = [(f, self._files[f], flags(f)) for f in self._files]
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	1102 return _text(sorted(dirs + files))
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1103
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1104 def read(self, gettext, readsubtree):
26402 05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1105 def _load_for_read(s):
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1106 s.parse(gettext(), readsubtree)
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1107 s._dirty = False
05871262acd5 treemanifest: rework lazy-copying code (issue4840) Augie Fackler <augie@google.com> parents: 26401 diff changeset	1108 self._loadfunc = _load_for_read
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1109
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1110 def writesubtrees(self, m1, m2, writesubtree):
25222 0de132d5328a treemanifest: lazily load manifests Martin von Zweigbergk <martinvonz@google.com> parents: 25221 diff changeset	1111 self._load() # for consistency; should never have any effect here
29892 8a84347b9907 manifest: call m1.load and m2.load before writing a subtree Durham Goode <durham@fb.com> parents: 29837 diff changeset	1112 m1._load()
8a84347b9907 manifest: call m1.load and m2.load before writing a subtree Durham Goode <durham@fb.com> parents: 29837 diff changeset	1113 m2._load()
25091 b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1114 emptytree = treemanifest()
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1115 for d, subm in self._dirs.iteritems():
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1116 subp1 = m1._dirs.get(d, emptytree)._node
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1117 subp2 = m2._dirs.get(d, emptytree)._node
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1118 if subp1 == revlog.nullid:
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1119 subp1, subp2 = subp2, subp1
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1120 writesubtree(subm, subp1, subp2)
b5052fc73300 treemanifest: store submanifest revlog per directory Martin von Zweigbergk <martinvonz@google.com> parents: 24956 diff changeset	1121
31876 94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1122 def walksubtrees(self, matcher=None):
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1123 """Returns an iterator of the subtrees of this manifest, including this
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1124 manifest itself.
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1125
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1126 If `matcher` is provided, it only returns subtrees that match.
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1127 """
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1128 if matcher and not matcher.visitdir(self._dir[:-1] or '.'):
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1129 return
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1130 if not matcher or matcher(self._dir[:-1]):
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1131 yield self
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1132
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1133 self._load()
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1134 for d, subm in self._dirs.iteritems():
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1135 for subtree in subm.walksubtrees(matcher=matcher):
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1136 yield subtree
94c1d3c1aea2 treemanifest: add walksubtrees api Durham Goode <durham@fb.com> parents: 31790 diff changeset	1137
29835 58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1138 class manifestrevlog(revlog.revlog):
58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1139 '''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: 29834 diff changeset	1140 full-text manifest contents.
58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1141 '''
32292 d67991c4fefe treemanifest: allow manifestrevlog to take an explicit treemanifest arg Durham Goode <durham@fb.com> parents: 32240 diff changeset	1142 def __init__(self, opener, dir='', dirlogcache=None, indexfile=None,
d67991c4fefe treemanifest: allow manifestrevlog to take an explicit treemanifest arg Durham Goode <durham@fb.com> parents: 32240 diff changeset	1143 treemanifest=False):
31161 6d9f8bc2b5ea manifest: allow specifying the revlog filename Durham Goode <durham@fb.com> parents: 31114 diff changeset	1144 """Constructs a new manifest revlog
6d9f8bc2b5ea manifest: allow specifying the revlog filename Durham Goode <durham@fb.com> parents: 31114 diff changeset	1145
6d9f8bc2b5ea manifest: allow specifying the revlog filename Durham Goode <durham@fb.com> parents: 31114 diff changeset	1146 `indexfile` - used by extensions to have two manifests at once, like
6d9f8bc2b5ea manifest: allow specifying the revlog filename Durham Goode <durham@fb.com> parents: 31114 diff changeset	1147 when transitioning between flatmanifeset and treemanifests.
32292 d67991c4fefe treemanifest: allow manifestrevlog to take an explicit treemanifest arg Durham Goode <durham@fb.com> parents: 32240 diff changeset	1148
d67991c4fefe treemanifest: allow manifestrevlog to take an explicit treemanifest arg Durham Goode <durham@fb.com> parents: 32240 diff changeset	1149 `treemanifest` - used to indicate this is a tree manifest revlog. Opener
d67991c4fefe treemanifest: allow manifestrevlog to take an explicit treemanifest arg Durham Goode <durham@fb.com> parents: 32240 diff changeset	1150 options can also be used to make this a tree manifest revlog. The opener
d67991c4fefe treemanifest: allow manifestrevlog to take an explicit treemanifest arg Durham Goode <durham@fb.com> parents: 32240 diff changeset	1151 option takes precedence, so if it is set to True, we ignore whatever
d67991c4fefe treemanifest: allow manifestrevlog to take an explicit treemanifest arg Durham Goode <durham@fb.com> parents: 32240 diff changeset	1152 value is passed in to the constructor.
31161 6d9f8bc2b5ea manifest: allow specifying the revlog filename Durham Goode <durham@fb.com> parents: 31114 diff changeset	1153 """
29835 58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1154 # During normal operations, we expect to deal with not more than four
58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1155 # revs at a time (such as during commit --amend). When rebasing large
58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1156 # stacks of commits, the number can go up, hence the config knob below.
58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1157 cachesize = 4
32292 d67991c4fefe treemanifest: allow manifestrevlog to take an explicit treemanifest arg Durham Goode <durham@fb.com> parents: 32240 diff changeset	1158 optiontreemanifest = False
29835 58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1159 opts = getattr(opener, 'options', None)
58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1160 if opts is not None:
58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1161 cachesize = opts.get('manifestcachesize', cachesize)
32292 d67991c4fefe treemanifest: allow manifestrevlog to take an explicit treemanifest arg Durham Goode <durham@fb.com> parents: 32240 diff changeset	1162 optiontreemanifest = opts.get('treemanifest', False)
29944 fa145a205a7f manifest: move revlog specific options from manifest to manifestrevlog Durham Goode <durham@fb.com> parents: 29943 diff changeset	1163
32292 d67991c4fefe treemanifest: allow manifestrevlog to take an explicit treemanifest arg Durham Goode <durham@fb.com> parents: 32240 diff changeset	1164 self._treeondisk = optiontreemanifest or treemanifest
29944 fa145a205a7f manifest: move revlog specific options from manifest to manifestrevlog Durham Goode <durham@fb.com> parents: 29943 diff changeset	1165
29835 58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1166 self._fulltextcache = util.lrucachedict(cachesize)
58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1167
29944 fa145a205a7f manifest: move revlog specific options from manifest to manifestrevlog Durham Goode <durham@fb.com> parents: 29943 diff changeset	1168 if dir:
fa145a205a7f manifest: move revlog specific options from manifest to manifestrevlog Durham Goode <durham@fb.com> parents: 29943 diff changeset	1169 assert self._treeondisk, 'opts is %r' % opts
31161 6d9f8bc2b5ea manifest: allow specifying the revlog filename Durham Goode <durham@fb.com> parents: 31114 diff changeset	1170
6d9f8bc2b5ea manifest: allow specifying the revlog filename Durham Goode <durham@fb.com> parents: 31114 diff changeset	1171 if indexfile is None:
6d9f8bc2b5ea manifest: allow specifying the revlog filename Durham Goode <durham@fb.com> parents: 31114 diff changeset	1172 indexfile = '00manifest.i'
6d9f8bc2b5ea manifest: allow specifying the revlog filename Durham Goode <durham@fb.com> parents: 31114 diff changeset	1173 if dir:
6d9f8bc2b5ea manifest: allow specifying the revlog filename Durham Goode <durham@fb.com> parents: 31114 diff changeset	1174 indexfile = "meta/" + dir + indexfile
6d9f8bc2b5ea manifest: allow specifying the revlog filename Durham Goode <durham@fb.com> parents: 31114 diff changeset	1175
29944 fa145a205a7f manifest: move revlog specific options from manifest to manifestrevlog Durham Goode <durham@fb.com> parents: 29943 diff changeset	1176 self._dir = dir
29945 1cc93a154723 manifest: move dirlog up to manifestrevlog Durham Goode <durham@fb.com> parents: 29944 diff changeset	1177 # The dirlogcache is kept on the root manifest log
1cc93a154723 manifest: move dirlog up to manifestrevlog Durham Goode <durham@fb.com> parents: 29944 diff changeset	1178 if dir:
1cc93a154723 manifest: move dirlog up to manifestrevlog Durham Goode <durham@fb.com> parents: 29944 diff changeset	1179 self._dirlogcache = dirlogcache
1cc93a154723 manifest: move dirlog up to manifestrevlog Durham Goode <durham@fb.com> parents: 29944 diff changeset	1180 else:
1cc93a154723 manifest: move dirlog up to manifestrevlog Durham Goode <durham@fb.com> parents: 29944 diff changeset	1181 self._dirlogcache = {'': self}
29944 fa145a205a7f manifest: move revlog specific options from manifest to manifestrevlog Durham Goode <durham@fb.com> parents: 29943 diff changeset	1182
30002 14ad8e2a4abe manifest: specify checkambig=True to revlog.__init__, to avoid ambiguity FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29966 diff changeset	1183 super(manifestrevlog, self).__init__(opener, indexfile,
33177 3b85c474cbcf manifest: apply checkambig=True only for root 00manifest.i FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 32583 diff changeset	1184 # only root indexfile is cached
34303 3c9691728237 revlog: add option to mmap revlog index Mark Thomas <mbthomas@fb.com> parents: 33177 diff changeset	1185 checkambig=not bool(dir),
3c9691728237 revlog: add option to mmap revlog index Mark Thomas <mbthomas@fb.com> parents: 33177 diff changeset	1186 mmaplargeindex=True)
29944 fa145a205a7f manifest: move revlog specific options from manifest to manifestrevlog Durham Goode <durham@fb.com> parents: 29943 diff changeset	1187
29835 58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1188 @property
58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1189 def fulltextcache(self):
58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1190 return self._fulltextcache
58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1191
58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1192 def clearcaches(self):
58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1193 super(manifestrevlog, self).clearcaches()
58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1194 self._fulltextcache.clear()
29945 1cc93a154723 manifest: move dirlog up to manifestrevlog Durham Goode <durham@fb.com> parents: 29944 diff changeset	1195 self._dirlogcache = {'': self}
1cc93a154723 manifest: move dirlog up to manifestrevlog Durham Goode <durham@fb.com> parents: 29944 diff changeset	1196
36133 59adb3051718 manifest: clean up dirlog() to take a d parameter to avoid shadowing dir() Augie Fackler <augie@google.com> parents: 35586 diff changeset	1197 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	1198 if d:
29945 1cc93a154723 manifest: move dirlog up to manifestrevlog Durham Goode <durham@fb.com> parents: 29944 diff changeset	1199 assert self._treeondisk
36133 59adb3051718 manifest: clean up dirlog() to take a d parameter to avoid shadowing dir() Augie Fackler <augie@google.com> parents: 35586 diff changeset	1200 if d not in self._dirlogcache:
59adb3051718 manifest: clean up dirlog() to take a d parameter to avoid shadowing dir() Augie Fackler <augie@google.com> parents: 35586 diff changeset	1201 mfrevlog = manifestrevlog(self.opener, d,
32292 d67991c4fefe treemanifest: allow manifestrevlog to take an explicit treemanifest arg Durham Goode <durham@fb.com> parents: 32240 diff changeset	1202 self._dirlogcache,
d67991c4fefe treemanifest: allow manifestrevlog to take an explicit treemanifest arg Durham Goode <durham@fb.com> parents: 32240 diff changeset	1203 treemanifest=self._treeondisk)
36133 59adb3051718 manifest: clean up dirlog() to take a d parameter to avoid shadowing dir() Augie Fackler <augie@google.com> parents: 35586 diff changeset	1204 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	1205 return self._dirlogcache[d]
29835 58d4ecdc531e manifest: make manifest derive from manifestrevlog Durham Goode <durham@fb.com> parents: 29834 diff changeset	1206
30378 ed45283a0ca7 manifest: remove dependency on manifestrevlog being able to create trees Durham Goode <durham@fb.com> parents: 30355 diff changeset	1207 def add(self, m, transaction, link, p1, p2, added, removed, readtree=None):
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	1208 if p1 in self.fulltextcache and util.safehasattr(m, 'fastdelta'):
29965 774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1209 # If our first parent is in the manifest cache, we can
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1210 # compute a delta here using properties we know about the
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1211 # manifest up-front, which may save time later for the
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1212 # revlog layer.
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1213
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1214 _checkforbidden(added)
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1215 # combine the changed lists into one sorted iterator
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1216 work = heapq.merge([(x, False) for x in added],
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1217 [(x, True) for x in removed])
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1218
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1219 arraytext, deltatext = m.fastdelta(self.fulltextcache[p1], work)
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1220 cachedelta = self.rev(p1), deltatext
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1221 text = util.buffer(arraytext)
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1222 n = self.addrevision(text, transaction, link, p1, p2, cachedelta)
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1223 else:
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1224 # The first parent manifest isn't already loaded, so we'll
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1225 # just encode a fulltext of the manifest and pass that
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1226 # through to the revlog layer, and let it handle the delta
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1227 # process.
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1228 if self._treeondisk:
30378 ed45283a0ca7 manifest: remove dependency on manifestrevlog being able to create trees Durham Goode <durham@fb.com> parents: 30355 diff changeset	1229 assert readtree, "readtree must be set for treemanifest writes"
ed45283a0ca7 manifest: remove dependency on manifestrevlog being able to create trees Durham Goode <durham@fb.com> parents: 30355 diff changeset	1230 m1 = readtree(self._dir, p1)
ed45283a0ca7 manifest: remove dependency on manifestrevlog being able to create trees Durham Goode <durham@fb.com> parents: 30355 diff changeset	1231 m2 = readtree(self._dir, p2)
ed45283a0ca7 manifest: remove dependency on manifestrevlog being able to create trees Durham Goode <durham@fb.com> parents: 30355 diff changeset	1232 n = self._addtree(m, transaction, link, m1, m2, readtree)
29965 774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1233 arraytext = None
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1234 else:
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	1235 text = m.text()
29965 774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1236 n = self.addrevision(text, transaction, link, p1, p2)
31355 2a18e9e6ca43 py3: use bytearray() instead of array('c', ...) constructions Augie Fackler <augie@google.com> parents: 31303 diff changeset	1237 arraytext = bytearray(text)
29965 774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1238
30209 9d06b65c5df2 manifest: don't store None in fulltextcache Martin von Zweigbergk <martinvonz@google.com> parents: 30207 diff changeset	1239 if arraytext is not None:
9d06b65c5df2 manifest: don't store None in fulltextcache Martin von Zweigbergk <martinvonz@google.com> parents: 30207 diff changeset	1240 self.fulltextcache[n] = arraytext
29965 774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1241
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1242 return n
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1243
30378 ed45283a0ca7 manifest: remove dependency on manifestrevlog being able to create trees Durham Goode <durham@fb.com> parents: 30355 diff changeset	1244 def _addtree(self, m, transaction, link, m1, m2, readtree):
29965 774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1245 # If the manifest is unchanged compared to one parent,
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1246 # don't write a new revision
31303 c134a33b1d73 treemanifest: make node reuse match flat manifest behavior Durham Goode <durham@fb.com> parents: 31265 diff changeset	1247 if self._dir != '' and (m.unmodifiedsince(m1) or m.unmodifiedsince(m2)):
29965 774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1248 return m.node()
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1249 def writesubtree(subm, subp1, subp2):
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1250 sublog = self.dirlog(subm.dir())
30378 ed45283a0ca7 manifest: remove dependency on manifestrevlog being able to create trees Durham Goode <durham@fb.com> parents: 30355 diff changeset	1251 sublog.add(subm, transaction, link, subp1, subp2, None, None,
ed45283a0ca7 manifest: remove dependency on manifestrevlog being able to create trees Durham Goode <durham@fb.com> parents: 30355 diff changeset	1252 readtree=readtree)
29965 774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1253 m.writesubtrees(m1, m2, writesubtree)
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	1254 text = m.dirtext()
31303 c134a33b1d73 treemanifest: make node reuse match flat manifest behavior Durham Goode <durham@fb.com> parents: 31265 diff changeset	1255 n = None
c134a33b1d73 treemanifest: make node reuse match flat manifest behavior Durham Goode <durham@fb.com> parents: 31265 diff changeset	1256 if self._dir != '':
c134a33b1d73 treemanifest: make node reuse match flat manifest behavior Durham Goode <durham@fb.com> parents: 31265 diff changeset	1257 # Double-check whether contents are unchanged to one parent
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	1258 if text == m1.dirtext():
31303 c134a33b1d73 treemanifest: make node reuse match flat manifest behavior Durham Goode <durham@fb.com> parents: 31265 diff changeset	1259 n = m1.node()
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	1260 elif text == m2.dirtext():
31303 c134a33b1d73 treemanifest: make node reuse match flat manifest behavior Durham Goode <durham@fb.com> parents: 31265 diff changeset	1261 n = m2.node()
c134a33b1d73 treemanifest: make node reuse match flat manifest behavior Durham Goode <durham@fb.com> parents: 31265 diff changeset	1262
c134a33b1d73 treemanifest: make node reuse match flat manifest behavior Durham Goode <durham@fb.com> parents: 31265 diff changeset	1263 if not n:
29965 774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1264 n = self.addrevision(text, transaction, link, m1.node(), m2.node())
31303 c134a33b1d73 treemanifest: make node reuse match flat manifest behavior Durham Goode <durham@fb.com> parents: 31265 diff changeset	1265
29965 774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1266 # Save nodeid so parent manifest can calculate its nodeid
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1267 m.setnode(n)
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1268 return n
774a15b129e8 manifest: move manifest.add onto manifestrevlog Durham Goode <durham@fb.com> parents: 29964 diff changeset	1269
38532 c82ea938efbb repository: define manifest interfaces Gregory Szorc <gregory.szorc@gmail.com> parents: 38514 diff changeset	1270 @interfaceutil.implementer(repository.imanifestlog)
29836 426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1271 class manifestlog(object):
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1272 """A collection class representing the collection of manifest snapshots
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1273 referenced by commits in the repository.
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1274
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1275 In this situation, 'manifest' refers to the abstract concept of a snapshot
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1276 of the list of files in the given commit. Consumers of the output of this
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1277 class do not care about the implementation details of the actual manifests
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1278 they receive (i.e. tree or flat or lazily loaded, etc)."""
29837 93b44aa17691 manifest: use property instead of field for manifest revlog storage Durham Goode <durham@fb.com> parents: 29836 diff changeset	1279 def __init__(self, opener, repo):
29963 483003c27938 manifest: move treeinmem onto manifestlog Durham Goode <durham@fb.com> parents: 29945 diff changeset	1280 usetreemanifest = False
30382 7c7d845f8b64 manifest: make manifestlog use it's own cache Durham Goode <durham@fb.com> parents: 30381 diff changeset	1281 cachesize = 4
29963 483003c27938 manifest: move treeinmem onto manifestlog Durham Goode <durham@fb.com> parents: 29945 diff changeset	1282
483003c27938 manifest: move treeinmem onto manifestlog Durham Goode <durham@fb.com> parents: 29945 diff changeset	1283 opts = getattr(opener, 'options', None)
483003c27938 manifest: move treeinmem onto manifestlog Durham Goode <durham@fb.com> parents: 29945 diff changeset	1284 if opts is not None:
483003c27938 manifest: move treeinmem onto manifestlog Durham Goode <durham@fb.com> parents: 29945 diff changeset	1285 usetreemanifest = opts.get('treemanifest', usetreemanifest)
30382 7c7d845f8b64 manifest: make manifestlog use it's own cache Durham Goode <durham@fb.com> parents: 30381 diff changeset	1286 cachesize = opts.get('manifestcachesize', cachesize)
29963 483003c27938 manifest: move treeinmem onto manifestlog Durham Goode <durham@fb.com> parents: 29945 diff changeset	1287 self._treeinmem = usetreemanifest
483003c27938 manifest: move treeinmem onto manifestlog Durham Goode <durham@fb.com> parents: 29945 diff changeset	1288
32240 9d3136638784 manifest: remove unused property _oldmanifest Martin von Zweigbergk <martinvonz@google.com> parents: 32220 diff changeset	1289 self._revlog = repo._constructmanifest()
37373 c50078fc32f3 narrow: move manifestrevlog overrides to core Martin von Zweigbergk <martinvonz@google.com> parents: 37372 diff changeset	1290 self._narrowmatch = repo.narrowmatch()
30219 3c8811efdddc manifest: make manifestlog a storecache Durham Goode <durham@fb.com> parents: 30209 diff changeset	1291
30306 d4b340bf68c5 manifest: change manifestlog mancache to be directory based Durham Goode <durham@fb.com> parents: 30305 diff changeset	1292 # A cache of the manifestctx or treemanifestctx for each directory
d4b340bf68c5 manifest: change manifestlog mancache to be directory based Durham Goode <durham@fb.com> parents: 30305 diff changeset	1293 self._dirmancache = {}
30382 7c7d845f8b64 manifest: make manifestlog use it's own cache Durham Goode <durham@fb.com> parents: 30381 diff changeset	1294 self._dirmancache[''] = util.lrucachedict(cachesize)
30306 d4b340bf68c5 manifest: change manifestlog mancache to be directory based Durham Goode <durham@fb.com> parents: 30305 diff changeset	1295
38514 561a450c7b64 manifest: make cachesize a private attribute Gregory Szorc <gregory.szorc@gmail.com> parents: 38340 diff changeset	1296 self._cachesize = cachesize
29837 93b44aa17691 manifest: use property instead of field for manifest revlog storage Durham Goode <durham@fb.com> parents: 29836 diff changeset	1297
29836 426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1298 def __getitem__(self, node):
30304 1a0c1ad57833 manifest: throw LookupError if node not in revlog Durham Goode <durham@fb.com> parents: 30221 diff changeset	1299 """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	1300 LookupError if not found.
29836 426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1301 """
30305 dc21ea3323c4 manifest: add manifestlog.get to obtain subdirectory instances Durham Goode <durham@fb.com> parents: 30304 diff changeset	1302 return self.get('', node)
29836 426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1303
30413 a431daa93f8c manifest: make revlog verification optional Durham Goode <durham@fb.com> parents: 30387 diff changeset	1304 def get(self, dir, node, verify=True):
30305 dc21ea3323c4 manifest: add manifestlog.get to obtain subdirectory instances Durham Goode <durham@fb.com> parents: 30304 diff changeset	1305 """Retrieves the manifest instance for the given node. Throws a
dc21ea3323c4 manifest: add manifestlog.get to obtain subdirectory instances Durham Goode <durham@fb.com> parents: 30304 diff changeset	1306 LookupError if not found.
30413 a431daa93f8c manifest: make revlog verification optional Durham Goode <durham@fb.com> parents: 30387 diff changeset	1307
a431daa93f8c manifest: make revlog verification optional Durham Goode <durham@fb.com> parents: 30387 diff changeset	1308 `verify` - if True an exception will be thrown if the node is not in
a431daa93f8c manifest: make revlog verification optional Durham Goode <durham@fb.com> parents: 30387 diff changeset	1309 the revlog
30305 dc21ea3323c4 manifest: add manifestlog.get to obtain subdirectory instances Durham Goode <durham@fb.com> parents: 30304 diff changeset	1310 """
30306 d4b340bf68c5 manifest: change manifestlog mancache to be directory based Durham Goode <durham@fb.com> parents: 30305 diff changeset	1311 if node in self._dirmancache.get(dir, ()):
32220 fb9b6bfb54b5 manifest: remove check for non-contexts in _dirmancache Martin von Zweigbergk <martinvonz@google.com> parents: 31876 diff changeset	1312 return self._dirmancache[dir][node]
30306 d4b340bf68c5 manifest: change manifestlog mancache to be directory based Durham Goode <durham@fb.com> parents: 30305 diff changeset	1313
37374 ac42e39b1b77 narrow: move manifestlog overrides to core Martin von Zweigbergk <martinvonz@google.com> parents: 37373 diff changeset	1314 if not self._narrowmatch.always():
ac42e39b1b77 narrow: move manifestlog overrides to core Martin von Zweigbergk <martinvonz@google.com> parents: 37373 diff changeset	1315 if not self._narrowmatch.visitdir(dir[:-1] or '.'):
ac42e39b1b77 narrow: move manifestlog overrides to core Martin von Zweigbergk <martinvonz@google.com> parents: 37373 diff changeset	1316 return excludeddirmanifestctx(dir, node)
30305 dc21ea3323c4 manifest: add manifestlog.get to obtain subdirectory instances Durham Goode <durham@fb.com> parents: 30304 diff changeset	1317 if dir:
dc21ea3323c4 manifest: add manifestlog.get to obtain subdirectory instances Durham Goode <durham@fb.com> parents: 30304 diff changeset	1318 if self._revlog._treeondisk:
30413 a431daa93f8c manifest: make revlog verification optional Durham Goode <durham@fb.com> parents: 30387 diff changeset	1319 if verify:
a431daa93f8c manifest: make revlog verification optional Durham Goode <durham@fb.com> parents: 30387 diff changeset	1320 dirlog = self._revlog.dirlog(dir)
a431daa93f8c manifest: make revlog verification optional Durham Goode <durham@fb.com> parents: 30387 diff changeset	1321 if node not in dirlog.nodemap:
a431daa93f8c manifest: make revlog verification optional Durham Goode <durham@fb.com> parents: 30387 diff changeset	1322 raise LookupError(node, dirlog.indexfile,
a431daa93f8c manifest: make revlog verification optional Durham Goode <durham@fb.com> parents: 30387 diff changeset	1323 _('no node'))
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1324 m = treemanifestctx(self, dir, node)
30305 dc21ea3323c4 manifest: add manifestlog.get to obtain subdirectory instances Durham Goode <durham@fb.com> parents: 30304 diff changeset	1325 else:
dc21ea3323c4 manifest: add manifestlog.get to obtain subdirectory instances Durham Goode <durham@fb.com> parents: 30304 diff changeset	1326 raise error.Abort(
dc21ea3323c4 manifest: add manifestlog.get to obtain subdirectory instances Durham Goode <durham@fb.com> parents: 30304 diff changeset	1327 _("cannot ask for manifest directory '%s' in a flat "
dc21ea3323c4 manifest: add manifestlog.get to obtain subdirectory instances Durham Goode <durham@fb.com> parents: 30304 diff changeset	1328 "manifest") % dir)
29911 4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1329 else:
30413 a431daa93f8c manifest: make revlog verification optional Durham Goode <durham@fb.com> parents: 30387 diff changeset	1330 if verify:
a431daa93f8c manifest: make revlog verification optional Durham Goode <durham@fb.com> parents: 30387 diff changeset	1331 if node not in self._revlog.nodemap:
a431daa93f8c manifest: make revlog verification optional Durham Goode <durham@fb.com> parents: 30387 diff changeset	1332 raise LookupError(node, self._revlog.indexfile,
a431daa93f8c manifest: make revlog verification optional Durham Goode <durham@fb.com> parents: 30387 diff changeset	1333 _('no node'))
30305 dc21ea3323c4 manifest: add manifestlog.get to obtain subdirectory instances Durham Goode <durham@fb.com> parents: 30304 diff changeset	1334 if self._treeinmem:
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1335 m = treemanifestctx(self, '', node)
30305 dc21ea3323c4 manifest: add manifestlog.get to obtain subdirectory instances Durham Goode <durham@fb.com> parents: 30304 diff changeset	1336 else:
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1337 m = manifestctx(self, node)
30306 d4b340bf68c5 manifest: change manifestlog mancache to be directory based Durham Goode <durham@fb.com> parents: 30305 diff changeset	1338
d4b340bf68c5 manifest: change manifestlog mancache to be directory based Durham Goode <durham@fb.com> parents: 30305 diff changeset	1339 if node != revlog.nullid:
d4b340bf68c5 manifest: change manifestlog mancache to be directory based Durham Goode <durham@fb.com> parents: 30305 diff changeset	1340 mancache = self._dirmancache.get(dir)
d4b340bf68c5 manifest: change manifestlog mancache to be directory based Durham Goode <durham@fb.com> parents: 30305 diff changeset	1341 if not mancache:
38514 561a450c7b64 manifest: make cachesize a private attribute Gregory Szorc <gregory.szorc@gmail.com> parents: 38340 diff changeset	1342 mancache = util.lrucachedict(self._cachesize)
30306 d4b340bf68c5 manifest: change manifestlog mancache to be directory based Durham Goode <durham@fb.com> parents: 30305 diff changeset	1343 self._dirmancache[dir] = mancache
d4b340bf68c5 manifest: change manifestlog mancache to be directory based Durham Goode <durham@fb.com> parents: 30305 diff changeset	1344 mancache[node] = m
29836 426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1345 return m
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1346
30380 10c924596e5c manifest: move clearcaches to manifestlog Durham Goode <durham@fb.com> parents: 30379 diff changeset	1347 def clearcaches(self):
10c924596e5c manifest: move clearcaches to manifestlog Durham Goode <durham@fb.com> parents: 30379 diff changeset	1348 self._dirmancache.clear()
10c924596e5c manifest: move clearcaches to manifestlog Durham Goode <durham@fb.com> parents: 30379 diff changeset	1349 self._revlog.clearcaches()
10c924596e5c manifest: move clearcaches to manifestlog Durham Goode <durham@fb.com> parents: 30379 diff changeset	1350
38556 f2f9bacf0587 manifest: define and implement rev() on manifestlog Gregory Szorc <gregory.szorc@gmail.com> parents: 38532 diff changeset	1351 def rev(self, node):
f2f9bacf0587 manifest: define and implement rev() on manifestlog Gregory Szorc <gregory.szorc@gmail.com> parents: 38532 diff changeset	1352 return self._revlog.rev(node)
f2f9bacf0587 manifest: define and implement rev() on manifestlog Gregory Szorc <gregory.szorc@gmail.com> parents: 38532 diff changeset	1353
38557 0db41eb0a3ac manifest: define and implement addgroup() on manifestlog Gregory Szorc <gregory.szorc@gmail.com> parents: 38556 diff changeset	1354 def addgroup(self, deltas, linkmapper, transaction):
0db41eb0a3ac manifest: define and implement addgroup() on manifestlog Gregory Szorc <gregory.szorc@gmail.com> parents: 38556 diff changeset	1355 return self._revlog.addgroup(deltas, linkmapper, transaction)
0db41eb0a3ac manifest: define and implement addgroup() on manifestlog Gregory Szorc <gregory.szorc@gmail.com> parents: 38556 diff changeset	1356
38532 c82ea938efbb repository: define manifest interfaces Gregory Szorc <gregory.szorc@gmail.com> parents: 38514 diff changeset	1357 @interfaceutil.implementer(repository.imanifestrevisionwritable)
30352 fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	1358 class memmanifestctx(object):
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1359 def __init__(self, manifestlog):
5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1360 self._manifestlog = manifestlog
30352 fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	1361 self._manifestdict = manifestdict()
fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	1362
30355 fa54f7ade491 manifest: remove manifest.add and add memmfctx.write Durham Goode <durham@fb.com> parents: 30353 diff changeset	1363 def _revlog(self):
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1364 return self._manifestlog._revlog
30355 fa54f7ade491 manifest: remove manifest.add and add memmfctx.write Durham Goode <durham@fb.com> parents: 30353 diff changeset	1365
30352 fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	1366 def new(self):
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1367 return memmanifestctx(self._manifestlog)
30352 fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	1368
30353 952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	1369 def copy(self):
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1370 memmf = memmanifestctx(self._manifestlog)
30353 952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	1371 memmf._manifestdict = self.read().copy()
952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	1372 return memmf
952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	1373
30352 fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	1374 def read(self):
fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	1375 return self._manifestdict
fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	1376
30355 fa54f7ade491 manifest: remove manifest.add and add memmfctx.write Durham Goode <durham@fb.com> parents: 30353 diff changeset	1377 def write(self, transaction, link, p1, p2, added, removed):
fa54f7ade491 manifest: remove manifest.add and add memmfctx.write Durham Goode <durham@fb.com> parents: 30353 diff changeset	1378 return self._revlog().add(self._manifestdict, transaction, link, p1, p2,
fa54f7ade491 manifest: remove manifest.add and add memmfctx.write Durham Goode <durham@fb.com> parents: 30353 diff changeset	1379 added, removed)
fa54f7ade491 manifest: remove manifest.add and add memmfctx.write Durham Goode <durham@fb.com> parents: 30353 diff changeset	1380
38532 c82ea938efbb repository: define manifest interfaces Gregory Szorc <gregory.szorc@gmail.com> parents: 38514 diff changeset	1381 @interfaceutil.implementer(repository.imanifestrevisionstored)
29930 be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1382 class manifestctx(object):
29836 426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1383 """A class representing a single revision of a manifest, including its
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1384 contents, its parent revs, and its linkrev.
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1385 """
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1386 def __init__(self, manifestlog, node):
5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1387 self._manifestlog = manifestlog
29930 be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1388 self._data = None
29836 426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1389
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1390 self._node = node
29911 4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1391
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1392 # TODO: We eventually want p1, p2, and linkrev exposed on this class,
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1393 # but let's add it later when something needs it and we can load it
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1394 # lazily.
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1395 #self.p1, self.p2 = revlog.parents(node)
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1396 #rev = revlog.rev(node)
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1397 #self.linkrev = revlog.linkrev(rev)
29836 426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1398
30351 3dfb5a0171c9 manifestctx: add _revlog() function Durham Goode <durham@fb.com> parents: 30350 diff changeset	1399 def _revlog(self):
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1400 return self._manifestlog._revlog
30351 3dfb5a0171c9 manifestctx: add _revlog() function Durham Goode <durham@fb.com> parents: 30350 diff changeset	1401
29836 426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1402 def node(self):
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1403 return self._node
426d931e5db2 manifest: introduce manifestlog and manifestctx classes Durham Goode <durham@fb.com> parents: 29835 diff changeset	1404
30352 fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	1405 def new(self):
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1406 return memmanifestctx(self._manifestlog)
30352 fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	1407
30353 952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	1408 def copy(self):
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1409 memmf = memmanifestctx(self._manifestlog)
30353 952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	1410 memmf._manifestdict = self.read().copy()
952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	1411 return memmf
952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	1412
30570 7fbc8a742b4d manifest: expose the parents() method Mateusz Kwapich <mitrandir@fb.com> parents: 30452 diff changeset	1413 @propertycache
7fbc8a742b4d manifest: expose the parents() method Mateusz Kwapich <mitrandir@fb.com> parents: 30452 diff changeset	1414 def parents(self):
7fbc8a742b4d manifest: expose the parents() method Mateusz Kwapich <mitrandir@fb.com> parents: 30452 diff changeset	1415 return self._revlog().parents(self._node)
7fbc8a742b4d manifest: expose the parents() method Mateusz Kwapich <mitrandir@fb.com> parents: 30452 diff changeset	1416
29930 be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1417 def read(self):
31114 4a1486c73fdf manifest: check 'if x is None' instead of 'if not x' Durham Goode <durham@fb.com> parents: 30570 diff changeset	1418 if self._data is None:
29930 be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1419 if self._node == revlog.nullid:
be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1420 self._data = manifestdict()
be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1421 else:
30351 3dfb5a0171c9 manifestctx: add _revlog() function Durham Goode <durham@fb.com> parents: 30350 diff changeset	1422 rl = self._revlog()
30220 acc8885a6450 manifest: make manifestctx store the repo Durham Goode <durham@fb.com> parents: 30219 diff changeset	1423 text = rl.revision(self._node)
31355 2a18e9e6ca43 py3: use bytearray() instead of array('c', ...) constructions Augie Fackler <augie@google.com> parents: 31303 diff changeset	1424 arraytext = bytearray(text)
30220 acc8885a6450 manifest: make manifestctx store the repo Durham Goode <durham@fb.com> parents: 30219 diff changeset	1425 rl._fulltextcache[self._node] = arraytext
29930 be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1426 self._data = manifestdict(text)
be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1427 return self._data
be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1428
30307 78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1429 def readfast(self, shallow=False):
30308 bce79dfcf5e4 manifest: get rid of manifest.readshallowfast Durham Goode <durham@fb.com> parents: 30307 diff changeset	1430 '''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: 30307 diff changeset	1431 readdelta is called if the delta is against the p1, and therefore can be
bce79dfcf5e4 manifest: get rid of manifest.readshallowfast Durham Goode <durham@fb.com> parents: 30307 diff changeset	1432 read quickly.
bce79dfcf5e4 manifest: get rid of manifest.readshallowfast Durham Goode <durham@fb.com> parents: 30307 diff changeset	1433
bce79dfcf5e4 manifest: get rid of manifest.readshallowfast Durham Goode <durham@fb.com> parents: 30307 diff changeset	1434 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: 30307 diff changeset	1435 '''
30351 3dfb5a0171c9 manifestctx: add _revlog() function Durham Goode <durham@fb.com> parents: 30350 diff changeset	1436 rl = self._revlog()
29943 80be4436e4cc manifest: adds manifestctx.readfast Durham Goode <durham@fb.com> parents: 29942 diff changeset	1437 r = rl.rev(self._node)
80be4436e4cc manifest: adds manifestctx.readfast Durham Goode <durham@fb.com> parents: 29942 diff changeset	1438 deltaparent = rl.deltaparent(r)
80be4436e4cc manifest: adds manifestctx.readfast Durham Goode <durham@fb.com> parents: 29942 diff changeset	1439 if deltaparent != revlog.nullrev and deltaparent in rl.parentrevs(r):
80be4436e4cc manifest: adds manifestctx.readfast Durham Goode <durham@fb.com> parents: 29942 diff changeset	1440 return self.readdelta()
80be4436e4cc manifest: adds manifestctx.readfast Durham Goode <durham@fb.com> parents: 29942 diff changeset	1441 return self.read()
80be4436e4cc manifest: adds manifestctx.readfast Durham Goode <durham@fb.com> parents: 29942 diff changeset	1442
30307 78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1443 def readdelta(self, shallow=False):
30309 f65faa4422c8 manifest: remove manifest.readshallowdelta Durham Goode <durham@fb.com> parents: 30308 diff changeset	1444 '''Returns a manifest containing just the entries that are present
f65faa4422c8 manifest: remove manifest.readshallowdelta Durham Goode <durham@fb.com> parents: 30308 diff changeset	1445 in this manifest, but not in its p1 manifest. This is efficient to read
f65faa4422c8 manifest: remove manifest.readshallowdelta Durham Goode <durham@fb.com> parents: 30308 diff changeset	1446 if the revlog delta is already p1.
f65faa4422c8 manifest: remove manifest.readshallowdelta Durham Goode <durham@fb.com> parents: 30308 diff changeset	1447
f65faa4422c8 manifest: remove manifest.readshallowdelta Durham Goode <durham@fb.com> parents: 30308 diff changeset	1448 Changing the value of `shallow` has no effect on flat manifests.
f65faa4422c8 manifest: remove manifest.readshallowdelta Durham Goode <durham@fb.com> parents: 30308 diff changeset	1449 '''
30351 3dfb5a0171c9 manifestctx: add _revlog() function Durham Goode <durham@fb.com> parents: 30350 diff changeset	1450 revlog = self._revlog()
29942 a059b17352ef manifest: add manifestctx.readdelta() Durham Goode <durham@fb.com> parents: 29930 diff changeset	1451 r = revlog.rev(self._node)
a059b17352ef manifest: add manifestctx.readdelta() Durham Goode <durham@fb.com> parents: 29930 diff changeset	1452 d = mdiff.patchtext(revlog.revdiff(revlog.deltaparent(r), r))
a059b17352ef manifest: add manifestctx.readdelta() Durham Goode <durham@fb.com> parents: 29930 diff changeset	1453 return manifestdict(d)
a059b17352ef manifest: add manifestctx.readdelta() Durham Goode <durham@fb.com> parents: 29930 diff changeset	1454
30350 608ba935e041 manifest: remove manifest.find Durham Goode <durham@fb.com> parents: 30348 diff changeset	1455 def find(self, key):
608ba935e041 manifest: remove manifest.find Durham Goode <durham@fb.com> parents: 30348 diff changeset	1456 return self.read().find(key)
608ba935e041 manifest: remove manifest.find Durham Goode <durham@fb.com> parents: 30348 diff changeset	1457
38532 c82ea938efbb repository: define manifest interfaces Gregory Szorc <gregory.szorc@gmail.com> parents: 38514 diff changeset	1458 @interfaceutil.implementer(repository.imanifestrevisionwritable)
30352 fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	1459 class memtreemanifestctx(object):
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1460 def __init__(self, manifestlog, dir=''):
5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1461 self._manifestlog = manifestlog
30352 fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	1462 self._dir = dir
fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	1463 self._treemanifest = treemanifest()
fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	1464
30355 fa54f7ade491 manifest: remove manifest.add and add memmfctx.write Durham Goode <durham@fb.com> parents: 30353 diff changeset	1465 def _revlog(self):
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1466 return self._manifestlog._revlog
30355 fa54f7ade491 manifest: remove manifest.add and add memmfctx.write Durham Goode <durham@fb.com> parents: 30353 diff changeset	1467
30352 fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	1468 def new(self, dir=''):
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1469 return memtreemanifestctx(self._manifestlog, dir=dir)
30352 fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	1470
30353 952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	1471 def copy(self):
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1472 memmf = memtreemanifestctx(self._manifestlog, dir=self._dir)
30353 952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	1473 memmf._treemanifest = self._treemanifest.copy()
952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	1474 return memmf
952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	1475
30352 fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	1476 def read(self):
fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	1477 return self._treemanifest
fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	1478
30355 fa54f7ade491 manifest: remove manifest.add and add memmfctx.write Durham Goode <durham@fb.com> parents: 30353 diff changeset	1479 def write(self, transaction, link, p1, p2, added, removed):
30378 ed45283a0ca7 manifest: remove dependency on manifestrevlog being able to create trees Durham Goode <durham@fb.com> parents: 30355 diff changeset	1480 def readtree(dir, node):
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1481 return self._manifestlog.get(dir, node).read()
30355 fa54f7ade491 manifest: remove manifest.add and add memmfctx.write Durham Goode <durham@fb.com> parents: 30353 diff changeset	1482 return self._revlog().add(self._treemanifest, transaction, link, p1, p2,
30378 ed45283a0ca7 manifest: remove dependency on manifestrevlog being able to create trees Durham Goode <durham@fb.com> parents: 30355 diff changeset	1483 added, removed, readtree=readtree)
30355 fa54f7ade491 manifest: remove manifest.add and add memmfctx.write Durham Goode <durham@fb.com> parents: 30353 diff changeset	1484
38532 c82ea938efbb repository: define manifest interfaces Gregory Szorc <gregory.szorc@gmail.com> parents: 38514 diff changeset	1485 @interfaceutil.implementer(repository.imanifestrevisionstored)
29930 be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1486 class treemanifestctx(object):
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1487 def __init__(self, manifestlog, dir, node):
5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1488 self._manifestlog = manifestlog
29911 4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1489 self._dir = dir
29930 be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1490 self._data = None
29911 4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1491
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1492 self._node = node
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1493
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1494 # TODO: Load p1/p2/linkrev lazily. They need to be lazily loaded so that
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1495 # we can instantiate treemanifestctx objects for directories we don't
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1496 # have on disk.
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1497 #self.p1, self.p2 = revlog.parents(node)
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1498 #rev = revlog.rev(node)
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1499 #self.linkrev = revlog.linkrev(rev)
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1500
30221 f2c5b9d48b29 manifest: make treemanifestctx store the repo Durham Goode <durham@fb.com> parents: 30220 diff changeset	1501 def _revlog(self):
37373 c50078fc32f3 narrow: move manifestrevlog overrides to core Martin von Zweigbergk <martinvonz@google.com> parents: 37372 diff changeset	1502 narrowmatch = self._manifestlog._narrowmatch
c50078fc32f3 narrow: move manifestrevlog overrides to core Martin von Zweigbergk <martinvonz@google.com> parents: 37372 diff changeset	1503 if not narrowmatch.always():
c50078fc32f3 narrow: move manifestrevlog overrides to core Martin von Zweigbergk <martinvonz@google.com> parents: 37372 diff changeset	1504 if not narrowmatch.visitdir(self._dir[:-1] or '.'):
c50078fc32f3 narrow: move manifestrevlog overrides to core Martin von Zweigbergk <martinvonz@google.com> parents: 37372 diff changeset	1505 return excludedmanifestrevlog(self._dir)
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1506 return self._manifestlog._revlog.dirlog(self._dir)
30221 f2c5b9d48b29 manifest: make treemanifestctx store the repo Durham Goode <durham@fb.com> parents: 30220 diff changeset	1507
29930 be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1508 def read(self):
31114 4a1486c73fdf manifest: check 'if x is None' instead of 'if not x' Durham Goode <durham@fb.com> parents: 30570 diff changeset	1509 if self._data is None:
30221 f2c5b9d48b29 manifest: make treemanifestctx store the repo Durham Goode <durham@fb.com> parents: 30220 diff changeset	1510 rl = self._revlog()
29930 be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1511 if self._node == revlog.nullid:
be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1512 self._data = treemanifest()
30221 f2c5b9d48b29 manifest: make treemanifestctx store the repo Durham Goode <durham@fb.com> parents: 30220 diff changeset	1513 elif rl._treeondisk:
29930 be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1514 m = treemanifest(dir=self._dir)
be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1515 def gettext():
30221 f2c5b9d48b29 manifest: make treemanifestctx store the repo Durham Goode <durham@fb.com> parents: 30220 diff changeset	1516 return rl.revision(self._node)
29930 be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1517 def readsubtree(dir, subm):
30414 a1beadaa4061 manifest: change treemanifestctx to construct subtrees from the manifestlog Durham Goode <durham@fb.com> parents: 30413 diff changeset	1518 # Set verify to False since we need to be able to create
a1beadaa4061 manifest: change treemanifestctx to construct subtrees from the manifestlog Durham Goode <durham@fb.com> parents: 30413 diff changeset	1519 # subtrees for trees that don't exist on disk.
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1520 return self._manifestlog.get(dir, subm, verify=False).read()
29930 be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1521 m.read(gettext, readsubtree)
be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1522 m.setnode(self._node)
be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1523 self._data = m
be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1524 else:
30348 b0ca939414ea treemanifest: fix a "treeinmem" case Martin von Zweigbergk <martinvonz@google.com> parents: 30341 diff changeset	1525 text = rl.revision(self._node)
31355 2a18e9e6ca43 py3: use bytearray() instead of array('c', ...) constructions Augie Fackler <augie@google.com> parents: 31303 diff changeset	1526 arraytext = bytearray(text)
30221 f2c5b9d48b29 manifest: make treemanifestctx store the repo Durham Goode <durham@fb.com> parents: 30220 diff changeset	1527 rl.fulltextcache[self._node] = arraytext
29930 be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1528 self._data = treemanifest(dir=self._dir, text=text)
be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1529
be16091ac14d manifest: change manifestctx to not inherit from manifestdict Durham Goode <durham@fb.com> parents: 29920 diff changeset	1530 return self._data
29911 4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1531
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1532 def node(self):
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1533 return self._node
4fb4fc331699 manifest: add treemanifestctx class Durham Goode <durham@fb.com> parents: 29892 diff changeset	1534
30352 fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	1535 def new(self, dir=''):
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1536 return memtreemanifestctx(self._manifestlog, dir=dir)
30352 fe1ee393de78 manifest: introduce memmanifestctx and memtreemanifestctx Durham Goode <durham@fb.com> parents: 30351 diff changeset	1537
30353 952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	1538 def copy(self):
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1539 memmf = memtreemanifestctx(self._manifestlog, dir=self._dir)
30353 952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	1540 memmf._treemanifest = self.read().copy()
952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	1541 return memmf
952e1916ae56 manifest: add copy to mfctx classes Durham Goode <durham@fb.com> parents: 30352 diff changeset	1542
30570 7fbc8a742b4d manifest: expose the parents() method Mateusz Kwapich <mitrandir@fb.com> parents: 30452 diff changeset	1543 @propertycache
7fbc8a742b4d manifest: expose the parents() method Mateusz Kwapich <mitrandir@fb.com> parents: 30452 diff changeset	1544 def parents(self):
7fbc8a742b4d manifest: expose the parents() method Mateusz Kwapich <mitrandir@fb.com> parents: 30452 diff changeset	1545 return self._revlog().parents(self._node)
7fbc8a742b4d manifest: expose the parents() method Mateusz Kwapich <mitrandir@fb.com> parents: 30452 diff changeset	1546
30307 78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1547 def readdelta(self, shallow=False):
30309 f65faa4422c8 manifest: remove manifest.readshallowdelta Durham Goode <durham@fb.com> parents: 30308 diff changeset	1548 '''Returns a manifest containing just the entries that are present
f65faa4422c8 manifest: remove manifest.readshallowdelta Durham Goode <durham@fb.com> parents: 30308 diff changeset	1549 in this manifest, but not in its p1 manifest. This is efficient to read
f65faa4422c8 manifest: remove manifest.readshallowdelta Durham Goode <durham@fb.com> parents: 30308 diff changeset	1550 if the revlog delta is already p1.
f65faa4422c8 manifest: remove manifest.readshallowdelta Durham Goode <durham@fb.com> parents: 30308 diff changeset	1551
f65faa4422c8 manifest: remove manifest.readshallowdelta Durham Goode <durham@fb.com> parents: 30308 diff changeset	1552 If `shallow` is True, this will read the delta for this directory,
f65faa4422c8 manifest: remove manifest.readshallowdelta Durham Goode <durham@fb.com> parents: 30308 diff changeset	1553 without recursively reading subdirectory manifests. Instead, any
f65faa4422c8 manifest: remove manifest.readshallowdelta Durham Goode <durham@fb.com> parents: 30308 diff changeset	1554 subdirectory entry will be reported as it appears in the manifest, i.e.
f65faa4422c8 manifest: remove manifest.readshallowdelta Durham Goode <durham@fb.com> parents: 30308 diff changeset	1555 the subdirectory will be reported among files and distinguished only by
f65faa4422c8 manifest: remove manifest.readshallowdelta Durham Goode <durham@fb.com> parents: 30308 diff changeset	1556 its 't' flag.
f65faa4422c8 manifest: remove manifest.readshallowdelta Durham Goode <durham@fb.com> parents: 30308 diff changeset	1557 '''
30221 f2c5b9d48b29 manifest: make treemanifestctx store the repo Durham Goode <durham@fb.com> parents: 30220 diff changeset	1558 revlog = self._revlog()
36404 0147a4730420 cleanup: say goodbye to manifestv2 format Augie Fackler <augie@google.com> parents: 36334 diff changeset	1559 if shallow:
30307 78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1560 r = revlog.rev(self._node)
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1561 d = mdiff.patchtext(revlog.revdiff(revlog.deltaparent(r), r))
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1562 return manifestdict(d)
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1563 else:
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1564 # Need to perform a slow delta
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1565 r0 = revlog.deltaparent(revlog.rev(self._node))
31163 5cab44fd1257 manifest: remove _repo from manifestctx objects Durham Goode <durham@fb.com> parents: 31161 diff changeset	1566 m0 = self._manifestlog.get(self._dir, revlog.node(r0)).read()
30307 78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1567 m1 = self.read()
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1568 md = treemanifest(dir=self._dir)
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1569 for f, ((n0, fl0), (n1, fl1)) in m0.diff(m1).iteritems():
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1570 if n1:
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1571 md[f] = n1
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1572 if fl1:
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1573 md.setflag(f, fl1)
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1574 return md
29942 a059b17352ef manifest: add manifestctx.readdelta() Durham Goode <durham@fb.com> parents: 29930 diff changeset	1575
30307 78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1576 def readfast(self, shallow=False):
30308 bce79dfcf5e4 manifest: get rid of manifest.readshallowfast Durham Goode <durham@fb.com> parents: 30307 diff changeset	1577 '''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: 30307 diff changeset	1578 readdelta is called if the delta is against the p1, and therefore can be
bce79dfcf5e4 manifest: get rid of manifest.readshallowfast Durham Goode <durham@fb.com> parents: 30307 diff changeset	1579 read quickly.
bce79dfcf5e4 manifest: get rid of manifest.readshallowfast Durham Goode <durham@fb.com> parents: 30307 diff changeset	1580
bce79dfcf5e4 manifest: get rid of manifest.readshallowfast Durham Goode <durham@fb.com> parents: 30307 diff changeset	1581 If `shallow` is True, it only returns the entries from this manifest,
bce79dfcf5e4 manifest: get rid of manifest.readshallowfast Durham Goode <durham@fb.com> parents: 30307 diff changeset	1582 and not any submanifests.
bce79dfcf5e4 manifest: get rid of manifest.readshallowfast Durham Goode <durham@fb.com> parents: 30307 diff changeset	1583 '''
30221 f2c5b9d48b29 manifest: make treemanifestctx store the repo Durham Goode <durham@fb.com> parents: 30220 diff changeset	1584 rl = self._revlog()
29943 80be4436e4cc manifest: adds manifestctx.readfast Durham Goode <durham@fb.com> parents: 29942 diff changeset	1585 r = rl.rev(self._node)
80be4436e4cc manifest: adds manifestctx.readfast Durham Goode <durham@fb.com> parents: 29942 diff changeset	1586 deltaparent = rl.deltaparent(r)
30307 78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1587 if (deltaparent != revlog.nullrev and
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1588 deltaparent in rl.parentrevs(r)):
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1589 return self.readdelta(shallow=shallow)
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1590
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1591 if shallow:
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1592 return manifestdict(rl.revision(self._node))
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1593 else:
78f3c7166f0d manifest: add shallow option to treemanifestctx.readdelta and readfast Durham Goode <durham@fb.com> parents: 30306 diff changeset	1594 return self.read()
29943 80be4436e4cc manifest: adds manifestctx.readfast Durham Goode <durham@fb.com> parents: 29942 diff changeset	1595
30350 608ba935e041 manifest: remove manifest.find Durham Goode <durham@fb.com> parents: 30348 diff changeset	1596 def find(self, key):
608ba935e041 manifest: remove manifest.find Durham Goode <durham@fb.com> parents: 30348 diff changeset	1597 return self.read().find(key)
37372 1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1598
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1599 class excludeddir(treemanifest):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1600 """Stand-in for a directory that is excluded from the repository.
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1601
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1602 With narrowing active on a repository that uses treemanifests,
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1603 some of the directory revlogs will be excluded from the resulting
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1604 clone. This is a huge storage win for clients, but means we need
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1605 some sort of pseudo-manifest to surface to internals so we can
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1606 detect a merge conflict outside the narrowspec. That's what this
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1607 class is: it stands in for a directory whose node is known, but
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1608 whose contents are unknown.
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1609 """
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1610 def __init__(self, dir, node):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1611 super(excludeddir, self).__init__(dir)
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1612 self._node = node
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1613 # Add an empty file, which will be included by iterators and such,
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1614 # appearing as the directory itself (i.e. something like "dir/")
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1615 self._files[''] = node
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1616 self._flags[''] = 't'
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1617
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1618 # Manifests outside the narrowspec should never be modified, so avoid
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1619 # copying. This makes a noticeable difference when there are very many
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1620 # directories outside the narrowspec. Also, it makes sense for the copy to
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1621 # be of the same type as the original, which would not happen with the
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1622 # super type's copy().
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1623 def copy(self):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1624 return self
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1625
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1626 class excludeddirmanifestctx(treemanifestctx):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1627 """context wrapper for excludeddir - see that docstring for rationale"""
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1628 def __init__(self, dir, node):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1629 self._dir = dir
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1630 self._node = node
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1631
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1632 def read(self):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1633 return excludeddir(self._dir, self._node)
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1634
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1635 def write(self, *args):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1636 raise error.ProgrammingError(
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1637 'attempt to write manifest from excluded dir %s' % self._dir)
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1638
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1639 class excludedmanifestrevlog(manifestrevlog):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1640 """Stand-in for excluded treemanifest revlogs.
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1641
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1642 When narrowing is active on a treemanifest repository, we'll have
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1643 references to directories we can't see due to the revlog being
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1644 skipped. This class exists to conform to the manifestrevlog
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1645 interface for those directories and proactively prevent writes to
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1646 outside the narrowspec.
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1647 """
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1648
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1649 def __init__(self, dir):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1650 self._dir = dir
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1651
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1652 def __len__(self):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1653 raise error.ProgrammingError(
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1654 'attempt to get length of excluded dir %s' % self._dir)
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1655
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1656 def rev(self, node):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1657 raise error.ProgrammingError(
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1658 'attempt to get rev from excluded dir %s' % self._dir)
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1659
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1660 def linkrev(self, node):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1661 raise error.ProgrammingError(
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1662 'attempt to get linkrev from excluded dir %s' % self._dir)
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1663
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1664 def node(self, rev):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1665 raise error.ProgrammingError(
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1666 'attempt to get node from excluded dir %s' % self._dir)
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1667
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1668 def add(self, args, *kwargs):
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1669 # We should never write entries in dirlogs outside the narrow clone.
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1670 # However, the method still gets called from writesubtree() in
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1671 # _addtree(), so we need to handle it. We should possibly make that
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1672 # avoid calling add() with a clean manifest (_dirty is always False
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1673 # in excludeddir instances).
1b2fa531fd7a narrow: move excludeddir and related classes to core Martin von Zweigbergk <martinvonz@google.com> parents: 37272 diff changeset	1674 pass

Mercurial > public > mercurial-scm > hg-stable

annotate mercurial/manifest.py @ 38557:0db41eb0a3ac