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

equal deleted inserted replaced

-:49fd21f32695
+:6266d19556ad
 _noop = lambda s: None
 @interfaceutil.implementer(repository.imanifestdict)
 class treemanifest(object):
-def __init__(self, dir=b'', text=b''):
+def __init__(self, nodeconstants, dir=b'', text=b''):
 self._dir = dir
+self.nodeconstants = nodeconstants
 self._node = nullid
 self._loadfunc = _noop
 self._copyfunc = _noop
 self._dirty = False
 self._dirs = {}
 self._load()
 dir, subpath = _splittopdir(f)
 if dir:
 self._loadlazy(dir)
 if dir not in self._dirs:
-self._dirs[dir] = treemanifest(self._subpath(dir))
+self._dirs[dir] = treemanifest(
+self.nodeconstants, self._subpath(dir)
+)
 self._dirs[dir].__setitem__(subpath, n)
 else:
 # manifest nodes are either 20 bytes or 32 bytes,
 # depending on the hash in use. Assert this as historically
 # sometimes extra bytes were added.
 self._load()
 dir, subpath = _splittopdir(f)
 if dir:
 self._loadlazy(dir)
 if dir not in self._dirs:
-self._dirs[dir] = treemanifest(self._subpath(dir))
+self._dirs[dir] = treemanifest(
+self.nodeconstants, self._subpath(dir)
+)
 self._dirs[dir].setflag(subpath, flags)
 else:
 self._flags[f] = flags
 self._dirty = True
 def copy(self):
-copy = treemanifest(self._dir)
+copy = treemanifest(self.nodeconstants, self._dir)
 copy._node = self._node
 copy._dirty = self._dirty
 if self._copyfunc is _noop:
 def _copyfunc(s):
 return self.copy()
 visit = match.visitchildrenset(self._dir[:-1])
 if visit == b'all':
 return self.copy()
-ret = treemanifest(self._dir)
+ret = treemanifest(self.nodeconstants, self._dir)
 if not visit:
 return ret
 self._load()
 for fn in self._files:
 if match and not match.always():
 m1 = self._matches(match)
 m2 = m2._matches(match)
 return m1.diff(m2, clean=clean)
 result = {}
-emptytree = treemanifest()
+emptytree = treemanifest(self.nodeconstants)
 def _iterativediff(t1, t2, stack):
 """compares two tree manifests and append new tree-manifests which
 needs to be compared to stack"""
 if t1._node == t2._node and not t1._dirty and not t2._dirty:
 def writesubtrees(self, m1, m2, writesubtree, match):
 self._load()  # for consistency; should never have any effect here
 m1._load()
 m2._load()
-emptytree = treemanifest()
+emptytree = treemanifest(self.nodeconstants)
 def getnode(m, d):
 ld = m._lazydirs.get(d)
 if ld:
 return ld[0]
 full-text manifest contents.
 """
 def __init__(
 self,
+nodeconstants,
 opener,
 tree=b'',
 dirlogcache=None,
 indexfile=None,
 treemanifest=False,
 `treemanifest` - used to indicate this is a tree manifest revlog. Opener
 options can also be used to make this a tree manifest revlog. The opener
 option takes precedence, so if it is set to True, we ignore whatever
 value is passed in to the constructor.
 """
+self.nodeconstants = nodeconstants
 # During normal operations, we expect to deal with not more than four
 # revs at a time (such as during commit --amend). When rebasing large
 # stacks of commits, the number can go up, hence the config knob below.
 cachesize = 4
 optiontreemanifest = False
 def dirlog(self, d):
 if d:
 assert self._treeondisk
 if d not in self._dirlogcache:
 mfrevlog = manifestrevlog(
-self.opener, d, self._dirlogcache, treemanifest=self._treeondisk
+self.nodeconstants,
+self.opener,
+d,
+self._dirlogcache,
+treemanifest=self._treeondisk,
 )
 self._dirlogcache[d] = mfrevlog
 return self._dirlogcache[d]
 def add(
 of the list of files in the given commit. Consumers of the output of this
 class do not care about the implementation details of the actual manifests
 they receive (i.e. tree or flat or lazily loaded, etc)."""
 def __init__(self, opener, repo, rootstore, narrowmatch):
+self.nodeconstants = repo.nodeconstants
 usetreemanifest = False
 cachesize = 4
 opts = getattr(opener, 'options', None)
 if opts is not None:
 if node in self._dirmancache.get(tree, ()):
 return self._dirmancache[tree][node]
 if not self._narrowmatch.always():
 if not self._narrowmatch.visitdir(tree[:-1]):
-return excludeddirmanifestctx(tree, node)
+return excludeddirmanifestctx(self.nodeconstants, tree, node)
 if tree:
 if self._rootstore._treeondisk:
 if verify:
 # Side-effect is LookupError is raised if node doesn't
 # exist.
 @interfaceutil.implementer(repository.imanifestrevisionwritable)
 class memtreemanifestctx(object):
 def __init__(self, manifestlog, dir=b''):
 self._manifestlog = manifestlog
 self._dir = dir
-self._treemanifest = treemanifest()
+self._treemanifest = treemanifest(manifestlog.nodeconstants)
 def _storage(self):
 return self._manifestlog.getstorage(b'')
 def copy(self):
 def _storage(self):
 narrowmatch = self._manifestlog._narrowmatch
 if not narrowmatch.always():
 if not narrowmatch.visitdir(self._dir[:-1]):
-return excludedmanifestrevlog(self._dir)
+return excludedmanifestrevlog(
+self._manifestlog.nodeconstants, self._dir
+)
 return self._manifestlog.getstorage(self._dir)
 def read(self):
 if self._data is None:
 store = self._storage()
 if self._node == nullid:
-self._data = treemanifest()
+self._data = treemanifest(self._manifestlog.nodeconstants)
 # TODO accessing non-public API
 elif store._treeondisk:
-m = treemanifest(dir=self._dir)
+m = treemanifest(self._manifestlog.nodeconstants, dir=self._dir)
 def gettext():
 return store.revision(self._node)
 def readsubtree(dir, subm):
 text = pycompat.bytestr(store.fulltextcache[self._node])
 else:
 text = store.revision(self._node)
 arraytext = bytearray(text)
 store.fulltextcache[self._node] = arraytext
-self._data = treemanifest(dir=self._dir, text=text)
+self._data = treemanifest(
+self._manifestlog.nodeconstants, dir=self._dir, text=text
+)
 return self._data
 def node(self):
 return self._node
 else:
 # Need to perform a slow delta
 r0 = store.deltaparent(store.rev(self._node))
 m0 = self._manifestlog.get(self._dir, store.node(r0)).read()
 m1 = self.read()
-md = treemanifest(dir=self._dir)
+md = treemanifest(self._manifestlog.nodeconstants, dir=self._dir)
 for f, ((n0, fl0), (n1, fl1)) in pycompat.iteritems(m0.diff(m1)):
 if n1:
 md[f] = n1
 if fl1:
 md.setflag(f, fl1)
 detect a merge conflict outside the narrowspec. That's what this
 class is: it stands in for a directory whose node is known, but
 whose contents are unknown.
 """
-def __init__(self, dir, node):
+def __init__(self, nodeconstants, dir, node):
-super(excludeddir, self).__init__(dir)
+super(excludeddir, self).__init__(nodeconstants, dir)
 self._node = node
 # Add an empty file, which will be included by iterators and such,
 # appearing as the directory itself (i.e. something like "dir/")
 self._files[b''] = node
 self._flags[b''] = b't'
 class excludeddirmanifestctx(treemanifestctx):
 """context wrapper for excludeddir - see that docstring for rationale"""
-def __init__(self, dir, node):
+def __init__(self, nodeconstants, dir, node):
+self.nodeconstants = nodeconstants
 self._dir = dir
 self._node = node
 def read(self):
-return excludeddir(self._dir, self._node)
+return excludeddir(self.nodeconstants, self._dir, self._node)
 def readfast(self, shallow=False):
 # special version of readfast since we don't have underlying storage
 return self.read()
 skipped. This class exists to conform to the manifestrevlog
 interface for those directories and proactively prevent writes to
 outside the narrowspec.
 """
-def __init__(self, dir):
+def __init__(self, nodeconstants, dir):
+self.nodeconstants = nodeconstants
 self._dir = dir
 def __len__(self):
 raise error.ProgrammingError(
 b'attempt to get length of excluded dir %s' % self._dir

changeset 46780	6266d19556ad
parent 46715	45f0d5297698
child 46819	d4ba4d51f85f