This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9750

node: introduce nodeconstants class
ClosedPublic

Authored by joerg.sonnenberger on Jan 13 2021, 10:55 AM.

Details

Reviewers
indygreg
durin42
Group Reviewers
hg-reviewers
Commits
rHG6266d19556ad: node: introduce nodeconstants class
Summary

In preparing for moving from SHA1 hashes to a modern hash function,
place nullid and other constant magic vules in a class. Provide the
active set of constants in the repository and push it down. Provide
nullid directly in strategic places like the repository as it is
accessed very often. This changeset introduces the API change, but not
the mechanical replacement of the node.py attributes itself.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

joerg.sonnenberger added a comment.Jan 13 2021, 10:56 AM

This is the API changing part of D9465 without all the followup changes.

durin42 added a comment.Jan 13 2021, 2:47 PM

So, I'm still not sold on the "only one hash function in a repo, ever" constraint of the design this seems to imply. Is there a plan page or anything or is this all in your head?

joerg.sonnenberger added a comment.Jan 13 2021, 2:59 PM

I'm aiming more for "only one hash size in the repository" and the magic constants staying the same independent of the hash function. The hash itself is planned to be tagged, i.e. 248bit for the hash function and the trailing byte as type tag. The SHA1 replacement would use "01" and in principle allow for existing SHA1 nodes to embedded directly into the larger 256bit space as type "00".

durin42 requested changes to this revision.Mar 16 2021, 5:52 PM

Fair enough. This is ready, but needs rebased.

This revision now requires changes to proceed.Mar 16 2021, 5:52 PM
joerg.sonnenberger added a commit: rHG6266d19556ad: node: introduce nodeconstants class.Mar 17 2021, 1:50 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG6266d19556ad: node: introduce nodeconstants class (authored by joerg.sonnenberger). · Explain Why
This revision was automatically updated to reflect the committed changes.
martinvonz added a subscriber: martinvonz.Mar 19 2021, 3:34 PM

This made test-git-interop.t fail more than before. Can you send a fix? The end of the traceback looks like this:

+    File "/usr/local/google/home/martinvonz/hg/hgext/git/gitlog.py", line 221, in changelogrevision
+      return hgchangelog._changelogrevision(extra={})
+  TypeError: __init__() missing 1 required positional argument: 'manifest'
+  [1]

Revision Contents
Changeset List

Diff 24786

contrib/perf.py

@command(b'perfloadmarkers') @command(b'perfloadmarkers')
def perfloadmarkers(ui, repo): def perfloadmarkers(ui, repo):
"""benchmark the time to parse the on-disk markers for a repo """benchmark the time to parse the on-disk markers for a repo
Result is the number of markers in the repo.""" Result is the number of markers in the repo."""
timer, fm = gettimer(ui) timer, fm = gettimer(ui)
svfs = getsvfs(repo) svfs = getsvfs(repo)
timer(lambda: len(obsolete.obsstore(svfs))) timer(lambda: len(obsolete.obsstore(repo, svfs)))
fm.end() fm.end()
@command( @command(
b'perflrucachedict', b'perflrucachedict',
formatteropts formatteropts
+ [ + [
(b'', b'costlimit', 0, b'maximum total cost of items in cache'), (b'', b'costlimit', 0, b'maximum total cost of items in cache'),

hgext/absorb.py

return return
return nullfunc return nullfunc
class emptyfilecontext(object): class emptyfilecontext(object):
"""minimal filecontext representing an empty file""" """minimal filecontext representing an empty file"""
def __init__(self, repo):
self._repo = repo
def data(self): def data(self):
return b'' return b''
def node(self): def node(self):
return nullid return nullid
def uniq(lst): def uniq(lst):
if path in ctx: # but do not follow copy if path in ctx: # but do not follow copy
pctx = ctx.p1() pctx = ctx.p1()
break break
if pctx is not None: # need an extra immutable fctx if pctx is not None: # need an extra immutable fctx
if path in pctx: if path in pctx:
fctxs.append(pctx[path]) fctxs.append(pctx[path])
else: else:
fctxs.append(emptyfilecontext()) fctxs.append(emptyfilecontext(pctx.repo()))
fctxs.reverse() fctxs.reverse()
# note: we rely on a property of hg: filerev is not reused for linear # note: we rely on a property of hg: filerev is not reused for linear
# history. i.e. it's impossible to have: # history. i.e. it's impossible to have:
# changelog: 4----5----6 (linear, no merges) # changelog: 4----5----6 (linear, no merges)
# filelog: 1----2----1 # filelog: 1----2----1
# ^ reuse filerev (impossible) # ^ reuse filerev (impossible)
# because parents are part of the hash. if that's not true, we need to # because parents are part of the hash. if that's not true, we need to

hgext/git/gitlog.py

from __future__ import absolute_import from __future__ import absolute_import
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import ( from mercurial.node import (
bin, bin,
hex, hex,
nullhex, nullhex,
nullid, nullid,
nullrev, nullrev,
sha1nodeconstants,
wdirhex, wdirhex,
) )
from mercurial import ( from mercurial import (
ancestor, ancestor,
changelog as hgchangelog, changelog as hgchangelog,
dagop, dagop,
encoding, encoding,
error, error,
) )
# Reindex now to pick up changes. We omit the progress # Reindex now to pick up changes. We omit the progress
# and log callbacks because this will be very quick. # and log callbacks because this will be very quick.
index._index_repo(self.gitrepo, self._db) index._index_repo(self.gitrepo, self._db)
return oid.raw return oid.raw
class manifestlog(baselog): class manifestlog(baselog):
nodeconstants = sha1nodeconstants
def __getitem__(self, node): def __getitem__(self, node):
return self.get(b'', node) return self.get(b'', node)
def get(self, relpath, node): def get(self, relpath, node):
if node == nullid: if node == nullid:
# TODO: this should almost certainly be a memgittreemanifestctx # TODO: this should almost certainly be a memgittreemanifestctx
return manifest.memtreemanifestctx(self, relpath) return manifest.memtreemanifestctx(self, relpath)
commit = self.gitrepo[gitutil.togitnode(node)] commit = self.gitrepo[gitutil.togitnode(node)]

hgext/largefiles/lfutil.py

lfstoredir = longname lfstoredir = longname
opener = vfsmod.vfs(vfs.join(lfstoredir)) opener = vfsmod.vfs(vfs.join(lfstoredir))
lfdirstate = largefilesdirstate( lfdirstate = largefilesdirstate(
opener, opener,
ui, ui,
repo.root, repo.root,
repo.dirstate._validate, repo.dirstate._validate,
lambda: sparse.matcher(repo), lambda: sparse.matcher(repo),
repo.nodeconstants,
) )
# If the largefiles dirstate does not exist, populate and create # If the largefiles dirstate does not exist, populate and create
# it. This ensures that we create it on the first meaningful # it. This ensures that we create it on the first meaningful
# largefiles operation in a new clone. # largefiles operation in a new clone.
if create and not vfs.exists(vfs.join(lfstoredir, b'dirstate')): if create and not vfs.exists(vfs.join(lfstoredir, b'dirstate')):
matcher = getstandinmatcher(repo) matcher = getstandinmatcher(repo)
standins = repo.dirstate.walk( standins = repo.dirstate.walk(

hgext/sqlitestore.py

import struct import struct
import threading import threading
import zlib import zlib
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import ( from mercurial.node import (
nullid, nullid,
nullrev, nullrev,
sha1nodeconstants,
short, short,
) )
from mercurial.thirdparty import attr from mercurial.thirdparty import attr
from mercurial import ( from mercurial import (
ancestor, ancestor,
dagop, dagop,
encoding, encoding,
error, error,
node = attr.ib(default=None) node = attr.ib(default=None)
@interfaceutil.implementer(repository.ifilestorage) @interfaceutil.implementer(repository.ifilestorage)
class sqlitefilestore(object): class sqlitefilestore(object):
"""Implements storage for an individual tracked path.""" """Implements storage for an individual tracked path."""
def __init__(self, db, path, compression): def __init__(self, db, path, compression):
self.nullid = sha1nodeconstants.nullid
self._db = db self._db = db
self._path = path self._path = path
self._pathid = None self._pathid = None
# revnum -> node # revnum -> node
self._revtonode = {} self._revtonode = {}
# node -> revnum # node -> revnum

mercurial/bookmarks.py

for name, node in marks.items(): for name, node in marks.items():
binremotemarks[name] = bin(node) binremotemarks[name] = bin(node)
return binremotemarks return binremotemarks
_binaryentry = struct.Struct(b'>20sH') _binaryentry = struct.Struct(b'>20sH')
def binaryencode(bookmarks): def binaryencode(repo, bookmarks):
"""encode a '(bookmark, node)' iterable into a binary stream """encode a '(bookmark, node)' iterable into a binary stream
the binary format is: the binary format is:
<node><bookmark-length><bookmark-name> <node><bookmark-length><bookmark-name>
:node: is a 20 bytes binary node, :node: is a 20 bytes binary node,
:bookmark-length: an unsigned short, :bookmark-length: an unsigned short,
:bookmark-name: the name of the bookmark (of length <bookmark-length>) :bookmark-name: the name of the bookmark (of length <bookmark-length>)
wdirid (all bits set) will be used as a special value for "missing" wdirid (all bits set) will be used as a special value for "missing"
""" """
binarydata = [] binarydata = []
for book, node in bookmarks: for book, node in bookmarks:
if not node: # None or '' if not node: # None or ''
node = wdirid node = wdirid
binarydata.append(_binaryentry.pack(node, len(book))) binarydata.append(_binaryentry.pack(node, len(book)))
binarydata.append(book) binarydata.append(book)
return b''.join(binarydata) return b''.join(binarydata)
def binarydecode(stream): def binarydecode(repo, stream):
"""decode a binary stream into an '(bookmark, node)' iterable """decode a binary stream into an '(bookmark, node)' iterable
the binary format is: the binary format is:
<node><bookmark-length><bookmark-name> <node><bookmark-length><bookmark-name>
:node: is a 20 bytes binary node, :node: is a 20 bytes binary node,
:bookmark-length: an unsigned short, :bookmark-length: an unsigned short,

mercurial/branchmap.py

subsetname = subsettable.get(filtername) subsetname = subsettable.get(filtername)
if subsetname is not None: if subsetname is not None:
subset = repo.filtered(subsetname) subset = repo.filtered(subsetname)
bcache = self[subset].copy() bcache = self[subset].copy()
extrarevs = subset.changelog.filteredrevs - cl.filteredrevs extrarevs = subset.changelog.filteredrevs - cl.filteredrevs
revs.extend(r for r in extrarevs if r <= bcache.tiprev) revs.extend(r for r in extrarevs if r <= bcache.tiprev)
else: else:
# nothing to fall back on, start empty. # nothing to fall back on, start empty.
bcache = branchcache() bcache = branchcache(repo)
revs.extend(cl.revs(start=bcache.tiprev + 1)) revs.extend(cl.revs(start=bcache.tiprev + 1))
if revs: if revs:
bcache.update(repo, revs) bcache.update(repo, revs)
assert bcache.validfor(repo), filtername assert bcache.validfor(repo), filtername
self._per_filter[repo.filtername] = bcache self._per_filter[repo.filtername] = bcache
r = clrev(h) r = clrev(h)
b, c = clbranchinfo(r) b, c = clbranchinfo(r)
if c: if c:
closed.add(h) closed.add(h)
if rbheads: if rbheads:
rtiprev = max((int(clrev(node)) for node in rbheads)) rtiprev = max((int(clrev(node)) for node in rbheads))
cache = branchcache( cache = branchcache(
repo,
remotebranchmap, remotebranchmap,
repo[rtiprev].node(), repo[rtiprev].node(),
rtiprev, rtiprev,
closednodes=closed, closednodes=closed,
) )
# Try to stick it as low as possible # Try to stick it as low as possible
# filter above served are unlikely to be fetch from a clone # filter above served are unlikely to be fetch from a clone
The open/closed state is represented by a single letter 'o' or 'c'. The open/closed state is represented by a single letter 'o' or 'c'.
This field can be used to avoid changelog reads when determining if a This field can be used to avoid changelog reads when determining if a
branch head closes a branch or not. branch head closes a branch or not.
""" """
def __init__( def __init__(
self, self,
repo,
entries=(), entries=(),
tipnode=nullid, tipnode=nullid,
tiprev=nullrev, tiprev=nullrev,
filteredhash=None, filteredhash=None,
closednodes=None, closednodes=None,
hasnode=None, hasnode=None,
): ):
# type: (Union[Dict[bytes, List[bytes]], Iterable[Tuple[bytes, List[bytes]]]], bytes, int, Optional[bytes], Optional[Set[bytes]], Optional[Callable[[bytes], bool]]) -> None # type: (Union[Dict[bytes, List[bytes]], Iterable[Tuple[bytes, List[bytes]]]], bytes, int, Optional[bytes], Optional[Set[bytes]], Optional[Callable[[bytes], bool]]) -> None
"""hasnode is a function which can be used to verify whether changelog """hasnode is a function which can be used to verify whether changelog
has a given node or not. If it's not provided, we assume that every node has a given node or not. If it's not provided, we assume that every node
we have exists in changelog""" we have exists in changelog"""
self._repo = repo
self.tipnode = tipnode self.tipnode = tipnode
self.tiprev = tiprev self.tiprev = tiprev
self.filteredhash = filteredhash self.filteredhash = filteredhash
# closednodes is a set of nodes that close their branch. If the branch # closednodes is a set of nodes that close their branch. If the branch
# cache has been updated, it may contain nodes that are no longer # cache has been updated, it may contain nodes that are no longer
# heads. # heads.
if closednodes is None: if closednodes is None:
self._closednodes = set() self._closednodes = set()
cachekey = next(lineiter).rstrip(b'\n').split(b" ", 2) cachekey = next(lineiter).rstrip(b'\n').split(b" ", 2)
last, lrev = cachekey[:2] last, lrev = cachekey[:2]
last, lrev = bin(last), int(lrev) last, lrev = bin(last), int(lrev)
filteredhash = None filteredhash = None
hasnode = repo.changelog.hasnode hasnode = repo.changelog.hasnode
if len(cachekey) > 2: if len(cachekey) > 2:
filteredhash = bin(cachekey[2]) filteredhash = bin(cachekey[2])
bcache = cls( bcache = cls(
repo,
tipnode=last, tipnode=last,
tiprev=lrev, tiprev=lrev,
filteredhash=filteredhash, filteredhash=filteredhash,
hasnode=hasnode, hasnode=hasnode,
) )
if not bcache.validfor(repo): if not bcache.validfor(repo):
# invalidate the cache # invalidate the cache
raise ValueError('tip differs') raise ValueError('tip differs')
def iterheads(self): def iterheads(self):
""" returns all the heads """ """ returns all the heads """
self._verifyall() self._verifyall()
return pycompat.itervalues(self._entries) return pycompat.itervalues(self._entries)
def copy(self): def copy(self):
"""return an deep copy of the branchcache object""" """return an deep copy of the branchcache object"""
return type(self)( return type(self)(
self._repo,
self._entries, self._entries,
self.tipnode, self.tipnode,
self.tiprev, self.tiprev,
self.filteredhash, self.filteredhash,
self._closednodes, self._closednodes,
) )
def write(self, repo): def write(self, repo):

mercurial/bundle2.py

@parthandler(b'check:bookmarks') @parthandler(b'check:bookmarks')
def handlecheckbookmarks(op, inpart): def handlecheckbookmarks(op, inpart):
"""check location of bookmarks """check location of bookmarks
This part is to be used to detect push race regarding bookmark, it This part is to be used to detect push race regarding bookmark, it
contains binary encoded (bookmark, node) tuple. If the local state does contains binary encoded (bookmark, node) tuple. If the local state does
not marks the one in the part, a PushRaced exception is raised not marks the one in the part, a PushRaced exception is raised
""" """
bookdata = bookmarks.binarydecode(inpart) bookdata = bookmarks.binarydecode(op.repo, inpart)
msgstandard = ( msgstandard = (
b'remote repository changed while pushing - please try again ' b'remote repository changed while pushing - please try again '
b'(bookmark "%s" move from %s to %s)' b'(bookmark "%s" move from %s to %s)'
) )
msgmissing = ( msgmissing = (
b'remote repository changed while pushing - please try again ' b'remote repository changed while pushing - please try again '
b'(bookmark "%s" is missing, expected %s)' b'(bookmark "%s" is missing, expected %s)'
When mode is 'apply' (the default) the bookmark information is applied as When mode is 'apply' (the default) the bookmark information is applied as
is to the unbundling repository. Make sure a 'check:bookmarks' part is is to the unbundling repository. Make sure a 'check:bookmarks' part is
issued earlier to check for push races in such update. This behavior is issued earlier to check for push races in such update. This behavior is
suitable for pushing. suitable for pushing.
When mode is 'records', the information is recorded into the 'bookmarks' When mode is 'records', the information is recorded into the 'bookmarks'
records of the bundle operation. This behavior is suitable for pulling. records of the bundle operation. This behavior is suitable for pulling.
""" """
changes = bookmarks.binarydecode(inpart) changes = bookmarks.binarydecode(op.repo, inpart)
pushkeycompat = op.repo.ui.configbool( pushkeycompat = op.repo.ui.configbool(
b'server', b'bookmarks-pushkey-compat' b'server', b'bookmarks-pushkey-compat'
) )
bookmarksmode = op.modes.get(b'bookmarks', b'apply') bookmarksmode = op.modes.get(b'bookmarks', b'apply')
if bookmarksmode == b'apply': if bookmarksmode == b'apply':
tr = op.gettransaction() tr = op.gettransaction()

mercurial/bundlerepo.py

linkmapper = lambda x: x linkmapper = lambda x: x
bundlerevlog.__init__( bundlerevlog.__init__(
self, opener, self.indexfile, cgunpacker, linkmapper self, opener, self.indexfile, cgunpacker, linkmapper
) )
class bundlemanifest(bundlerevlog, manifest.manifestrevlog): class bundlemanifest(bundlerevlog, manifest.manifestrevlog):
def __init__( def __init__(
self, opener, cgunpacker, linkmapper, dirlogstarts=None, dir=b'' self,
nodeconstants,
opener,
cgunpacker,
linkmapper,
dirlogstarts=None,
dir=b'',
): ):
manifest.manifestrevlog.__init__(self, opener, tree=dir) manifest.manifestrevlog.__init__(self, nodeconstants, opener, tree=dir)
bundlerevlog.__init__( bundlerevlog.__init__(
self, opener, self.indexfile, cgunpacker, linkmapper self, opener, self.indexfile, cgunpacker, linkmapper
) )
if dirlogstarts is None: if dirlogstarts is None:
dirlogstarts = {} dirlogstarts = {}
if self.bundle.version == b"03": if self.bundle.version == b"03":
dirlogstarts = _getfilestarts(self.bundle) dirlogstarts = _getfilestarts(self.bundle)
self._dirlogstarts = dirlogstarts self._dirlogstarts = dirlogstarts
self._linkmapper = linkmapper self._linkmapper = linkmapper
def dirlog(self, d): def dirlog(self, d):
if d in self._dirlogstarts: if d in self._dirlogstarts:
self.bundle.seek(self._dirlogstarts[d]) self.bundle.seek(self._dirlogstarts[d])
return bundlemanifest( return bundlemanifest(
self.nodeconstants,
self.opener, self.opener,
self.bundle, self.bundle,
self._linkmapper, self._linkmapper,
self._dirlogstarts, self._dirlogstarts,
dir=d, dir=d,
) )
return super(bundlemanifest, self).dirlog(d) return super(bundlemanifest, self).dirlog(d)
pass pass
@localrepo.unfilteredpropertycache @localrepo.unfilteredpropertycache
def manifestlog(self): def manifestlog(self):
self._cgunpacker.seek(self.manstart) self._cgunpacker.seek(self.manstart)
# consume the header if it exists # consume the header if it exists
self._cgunpacker.manifestheader() self._cgunpacker.manifestheader()
linkmapper = self.unfiltered().changelog.rev linkmapper = self.unfiltered().changelog.rev
rootstore = bundlemanifest(self.svfs, self._cgunpacker, linkmapper) rootstore = bundlemanifest(
self.nodeconstants, self.svfs, self._cgunpacker, linkmapper
)
self.filestart = self._cgunpacker.tell() self.filestart = self._cgunpacker.tell()
return manifest.manifestlog( return manifest.manifestlog(
self.svfs, self, rootstore, self.narrowmatch() self.svfs, self, rootstore, self.narrowmatch()
) )
def _consumemanifest(self): def _consumemanifest(self):
"""Consumes the manifest portion of the bundle, setting filestart so the """Consumes the manifest portion of the bundle, setting filestart so the

mercurial/changegroup.py

if self._h: if self._h:
d, self._h = self._h[:n], self._h[n:] d, self._h = self._h[:n], self._h[n:]
if len(d) < n: if len(d) < n:
d += readexactly(self._fh, n - len(d)) d += readexactly(self._fh, n - len(d))
return d return d
return readexactly(self._fh, n) return readexactly(self._fh, n)
def _revisiondeltatochunks(delta, headerfn): def _revisiondeltatochunks(repo, delta, headerfn):
"""Serialize a revisiondelta to changegroup chunks.""" """Serialize a revisiondelta to changegroup chunks."""
# The captured revision delta may be encoded as a delta against # The captured revision delta may be encoded as a delta against
# a base revision or as a full revision. The changegroup format # a base revision or as a full revision. The changegroup format
# requires that everything on the wire be deltas. So for full # requires that everything on the wire be deltas. So for full
# revisions, we need to invent a header that says to rewrite # revisions, we need to invent a header that says to rewrite
# data. # data.
self._verbosenote(_(b'uncompressed size of bundle content:\n')) self._verbosenote(_(b'uncompressed size of bundle content:\n'))
size = 0 size = 0
clstate, deltas = self._generatechangelog( clstate, deltas = self._generatechangelog(
cl, clnodes, generate=changelog cl, clnodes, generate=changelog
) )
for delta in deltas: for delta in deltas:
for chunk in _revisiondeltatochunks(delta, self._builddeltaheader): for chunk in _revisiondeltatochunks(
self._repo, delta, self._builddeltaheader
):
size += len(chunk) size += len(chunk)
yield chunk yield chunk
close = closechunk() close = closechunk()
size += len(close) size += len(close)
yield closechunk() yield closechunk()
self._verbosenote(_(b'%8.i (changelog)\n') % size) self._verbosenote(_(b'%8.i (changelog)\n') % size)
for tree, deltas in it: for tree, deltas in it:
if tree: if tree:
assert self.version == b'03' assert self.version == b'03'
chunk = _fileheader(tree) chunk = _fileheader(tree)
size += len(chunk) size += len(chunk)
yield chunk yield chunk
for delta in deltas: for delta in deltas:
chunks = _revisiondeltatochunks(delta, self._builddeltaheader) chunks = _revisiondeltatochunks(
self._repo, delta, self._builddeltaheader
)
for chunk in chunks: for chunk in chunks:
size += len(chunk) size += len(chunk)
yield chunk yield chunk
close = closechunk() close = closechunk()
size += len(close) size += len(close)
yield close yield close
) )
for path, deltas in it: for path, deltas in it:
h = _fileheader(path) h = _fileheader(path)
size = len(h) size = len(h)
yield h yield h
for delta in deltas: for delta in deltas:
chunks = _revisiondeltatochunks(delta, self._builddeltaheader) chunks = _revisiondeltatochunks(
self._repo, delta, self._builddeltaheader
)
for chunk in chunks: for chunk in chunks:
size += len(chunk) size += len(chunk)
yield chunk yield chunk
close = closechunk() close = closechunk()
size += len(close) size += len(close)
yield close yield close

mercurial/changelog.py

return _delay return _delay
@attr.s @attr.s
class _changelogrevision(object): class _changelogrevision(object):
# Extensions might modify _defaultextra, so let the constructor below pass # Extensions might modify _defaultextra, so let the constructor below pass
# it in # it in
extra = attr.ib() extra = attr.ib()
manifest = attr.ib(default=nullid) manifest = attr.ib()
user = attr.ib(default=b'') user = attr.ib(default=b'')
date = attr.ib(default=(0, 0)) date = attr.ib(default=(0, 0))
files = attr.ib(default=attr.Factory(list)) files = attr.ib(default=attr.Factory(list))
filesadded = attr.ib(default=None) filesadded = attr.ib(default=None)
filesremoved = attr.ib(default=None) filesremoved = attr.ib(default=None)
p1copies = attr.ib(default=None) p1copies = attr.ib(default=None)
p2copies = attr.ib(default=None) p2copies = attr.ib(default=None)
description = attr.ib(default=b'') description = attr.ib(default=b'')
__slots__ = ( __slots__ = (
'_offsets', '_offsets',
'_text', '_text',
'_sidedata', '_sidedata',
'_cpsd', '_cpsd',
'_changes', '_changes',
) )
def __new__(cls, text, sidedata, cpsd): def __new__(cls, cl, text, sidedata, cpsd):
if not text: if not text:
return _changelogrevision(extra=_defaultextra) return _changelogrevision(extra=_defaultextra, manifest=nullid)
self = super(changelogrevision, cls).__new__(cls) self = super(changelogrevision, cls).__new__(cls)
# We could return here and implement the following as an __init__. # We could return here and implement the following as an __init__.
# But doing it here is equivalent and saves an extra function call. # But doing it here is equivalent and saves an extra function call.
# format used: # format used:
# nodeid\n : manifest node in ascii # nodeid\n : manifest node in ascii
# user\n : user, no \n or \r allowed # user\n : user, no \n or \r allowed
- dict of extra metadata - dict of extra metadata
Unless you need to access all fields, consider calling Unless you need to access all fields, consider calling
``changelogrevision`` instead, as it is faster for partial object ``changelogrevision`` instead, as it is faster for partial object
access. access.
""" """
d, s = self._revisiondata(node) d, s = self._revisiondata(node)
c = changelogrevision( c = changelogrevision(
d, s, self._copiesstorage == b'changeset-sidedata' self, d, s, self._copiesstorage == b'changeset-sidedata'
) )
return (c.manifest, c.user, c.date, c.files, c.description, c.extra) return (c.manifest, c.user, c.date, c.files, c.description, c.extra)
def changelogrevision(self, nodeorrev): def changelogrevision(self, nodeorrev):
"""Obtain a ``changelogrevision`` for a node or revision.""" """Obtain a ``changelogrevision`` for a node or revision."""
text, sidedata = self._revisiondata(nodeorrev) text, sidedata = self._revisiondata(nodeorrev)
return changelogrevision( return changelogrevision(
text, sidedata, self._copiesstorage == b'changeset-sidedata' self, text, sidedata, self._copiesstorage == b'changeset-sidedata'
) )
def readfiles(self, node): def readfiles(self, node):
""" """
short version of read that only returns the files modified by the cset short version of read that only returns the files modified by the cset
""" """
text = self.revision(node) text = self.revision(node)
if not text: if not text:

mercurial/dirstate.py

return os.fstat(tmpfd)[stat.ST_MTIME] return os.fstat(tmpfd)[stat.ST_MTIME]
finally: finally:
os.close(tmpfd) os.close(tmpfd)
vfs.unlink(tmpname) vfs.unlink(tmpname)
@interfaceutil.implementer(intdirstate.idirstate) @interfaceutil.implementer(intdirstate.idirstate)
class dirstate(object): class dirstate(object):
def __init__(self, opener, ui, root, validate, sparsematchfn): def __init__(
self, opener, ui, root, validate, sparsematchfn, nodeconstants
):
"""Create a new dirstate object. """Create a new dirstate object.
opener is an open()-like callable that can be used to open the opener is an open()-like callable that can be used to open the
dirstate file; root is the root of the directory tracked by dirstate file; root is the root of the directory tracked by
the dirstate. the dirstate.
""" """
self._nodeconstants = nodeconstants
self._opener = opener self._opener = opener
self._validate = validate self._validate = validate
self._root = root self._root = root
self._sparsematchfn = sparsematchfn self._sparsematchfn = sparsematchfn
# ntpath.join(root, '') of Python 2.7.9 does not add sep if root is # ntpath.join(root, '') of Python 2.7.9 does not add sep if root is
# UNC path pointing to root share (issue4557) # UNC path pointing to root share (issue4557)
self._rootdir = pathutil.normasprefix(root) self._rootdir = pathutil.normasprefix(root)
self._dirty = False self._dirty = False
"""Returns true if the dirstate is in the middle of a set of changes """Returns true if the dirstate is in the middle of a set of changes
that modify the dirstate parent. that modify the dirstate parent.
""" """
return self._parentwriters > 0 return self._parentwriters > 0
@propertycache @propertycache
def _map(self): def _map(self):
"""Return the dirstate contents (see documentation for dirstatemap).""" """Return the dirstate contents (see documentation for dirstatemap)."""
self._map = self._mapcls(self._ui, self._opener, self._root) self._map = self._mapcls(
self._ui, self._opener, self._root, self._nodeconstants
)
return self._map return self._map
@property @property
def _sparsematcher(self): def _sparsematcher(self):
"""The matcher for the sparse checkout. """The matcher for the sparse checkout.
The working directory may not include every file from a manifest. The The working directory may not include every file from a manifest. The
matcher obtained by this property will match a path if it is to be matcher obtained by this property will match a path if it is to be
- `filefoldmap` is a dict mapping normalized filenames to the denormalized - `filefoldmap` is a dict mapping normalized filenames to the denormalized
form that they appear as in the dirstate. form that they appear as in the dirstate.
- `dirfoldmap` is a dict mapping normalized directory names to the - `dirfoldmap` is a dict mapping normalized directory names to the
denormalized form that they appear as in the dirstate. denormalized form that they appear as in the dirstate.
""" """
def __init__(self, ui, opener, root): def __init__(self, ui, opener, root, nodeconstants):
self._ui = ui self._ui = ui
self._opener = opener self._opener = opener
self._root = root self._root = root
self._filename = b'dirstate' self._filename = b'dirstate'
self._nodelen = 20 self._nodelen = 20
self._nodeconstants = nodeconstants
self._parents = None self._parents = None
self._dirtyparents = False self._dirtyparents = False
# for consistent view between _pl() and _read() invocations # for consistent view between _pl() and _read() invocations
self._pendingmode = None self._pendingmode = None
@propertycache @propertycache
for name in self._dirs: for name in self._dirs:
f[normcase(name)] = name f[normcase(name)] = name
return f return f
if rustmod is not None: if rustmod is not None:
class dirstatemap(object): class dirstatemap(object):
def __init__(self, ui, opener, root): def __init__(self, ui, opener, root, nodeconstants):
self._nodeconstants = nodeconstants
self._ui = ui self._ui = ui
self._opener = opener self._opener = opener
self._root = root self._root = root
self._filename = b'dirstate' self._filename = b'dirstate'
self._parents = None self._parents = None
self._dirtyparents = False self._dirtyparents = False
# for consistent view between _pl() and _read() invocations # for consistent view between _pl() and _read() invocations

mercurial/discovery.py

# B. add new branch data # B. add new branch data
for branch in branches: for branch in branches:
if branch not in headssum: if branch not in headssum:
headssum[branch] = (None, [], []) headssum[branch] = (None, [], [])
# C. Update newmap with outgoing changes. # C. Update newmap with outgoing changes.
# This will possibly add new heads and remove existing ones. # This will possibly add new heads and remove existing ones.
newmap = branchmap.remotebranchcache( newmap = branchmap.remotebranchcache(
repo,
(
(branch, heads[1]) (branch, heads[1])
for branch, heads in pycompat.iteritems(headssum) for branch, heads in pycompat.iteritems(headssum)
if heads[0] is not None if heads[0] is not None
),
) )
newmap.update(repo, (ctx.rev() for ctx in missingctx)) newmap.update(repo, (ctx.rev() for ctx in missingctx))
for branch, newheads in pycompat.iteritems(newmap): for branch, newheads in pycompat.iteritems(newmap):
headssum[branch][1][:] = newheads headssum[branch][1][:] = newheads
for branch, items in pycompat.iteritems(headssum): for branch, items in pycompat.iteritems(headssum):
for l in items: for l in items:
if l is not None: if l is not None:
l.sort() l.sort()

mercurial/exchange.py

return return
b2caps = bundle2.bundle2caps(pushop.remote) b2caps = bundle2.bundle2caps(pushop.remote)
hasbookmarkcheck = b'bookmarks' in b2caps hasbookmarkcheck = b'bookmarks' in b2caps
if not (pushop.outbookmarks and hasbookmarkcheck): if not (pushop.outbookmarks and hasbookmarkcheck):
return return
data = [] data = []
for book, old, new in pushop.outbookmarks: for book, old, new in pushop.outbookmarks:
data.append((book, old)) data.append((book, old))
checkdata = bookmod.binaryencode(data) checkdata = bookmod.binaryencode(pushop.repo, data)
bundler.newpart(b'check:bookmarks', data=checkdata) bundler.newpart(b'check:bookmarks', data=checkdata)
@b2partsgenerator(b'check-phases') @b2partsgenerator(b'check-phases')
def _pushb2checkphases(pushop, bundler): def _pushb2checkphases(pushop, bundler):
"""insert phase move checking""" """insert phase move checking"""
if not _pushing(pushop) or pushop.force: if not _pushing(pushop) or pushop.force:
return return
return return
allactions = [] allactions = []
data = [] data = []
for book, old, new in pushop.outbookmarks: for book, old, new in pushop.outbookmarks:
_abortonsecretctx(pushop, new, book) _abortonsecretctx(pushop, new, book)
data.append((book, new)) data.append((book, new))
allactions.append((book, _bmaction(old, new))) allactions.append((book, _bmaction(old, new)))
checkdata = bookmod.binaryencode(data) checkdata = bookmod.binaryencode(pushop.repo, data)
bundler.newpart(b'bookmarks', data=checkdata) bundler.newpart(b'bookmarks', data=checkdata)
def handlereply(op): def handlereply(op):
ui = pushop.ui ui = pushop.ui
# if success # if success
for book, action in allactions: for book, action in allactions:
ui.status(bookmsgmap[action][0] % book) ui.status(bookmsgmap[action][0] % book)
bundler, repo, source, bundlecaps=None, b2caps=None, **kwargs bundler, repo, source, bundlecaps=None, b2caps=None, **kwargs
): ):
"""add a bookmark part to the requested bundle""" """add a bookmark part to the requested bundle"""
if not kwargs.get('bookmarks', False): if not kwargs.get('bookmarks', False):
return return
if not b2caps or b'bookmarks' not in b2caps: if not b2caps or b'bookmarks' not in b2caps:
raise error.Abort(_(b'no common bookmarks exchange method')) raise error.Abort(_(b'no common bookmarks exchange method'))
books = bookmod.listbinbookmarks(repo) books = bookmod.listbinbookmarks(repo)
data = bookmod.binaryencode(books) data = bookmod.binaryencode(repo, books)
if data: if data:
bundler.newpart(b'bookmarks', data=data) bundler.newpart(b'bookmarks', data=data)
@getbundle2partsgenerator(b'listkeys') @getbundle2partsgenerator(b'listkeys')
def _getbundlelistkeysparts( def _getbundlelistkeysparts(
bundler, repo, source, bundlecaps=None, b2caps=None, **kwargs bundler, repo, source, bundlecaps=None, b2caps=None, **kwargs
): ):

mercurial/filelog.py

class filelog(object): class filelog(object):
def __init__(self, opener, path): def __init__(self, opener, path):
self._revlog = revlog.revlog( self._revlog = revlog.revlog(
opener, b'/'.join((b'data', path + b'.i')), censorable=True opener, b'/'.join((b'data', path + b'.i')), censorable=True
) )
# Full name of the user visible file, relative to the repository root. # Full name of the user visible file, relative to the repository root.
# Used by LFS. # Used by LFS.
self._revlog.filename = path self._revlog.filename = path
self.nullid = self._revlog.nullid
def __len__(self): def __len__(self):
return len(self._revlog) return len(self._revlog)
def __iter__(self): def __iter__(self):
return self._revlog.__iter__() return self._revlog.__iter__()
def hasnode(self, node): def hasnode(self, node):

mercurial/interfaces/dirstate.py

from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
import contextlib import contextlib
from .. import node as nodemod from .. import node as nodemod
from . import util as interfaceutil from . import util as interfaceutil
class idirstate(interfaceutil.Interface): class idirstate(interfaceutil.Interface):
def __init__(opener, ui, root, validate, sparsematchfn): def __init__(opener, ui, root, validate, sparsematchfn, nodeconstants):
"""Create a new dirstate object. """Create a new dirstate object.
opener is an open()-like callable that can be used to open the opener is an open()-like callable that can be used to open the
dirstate file; root is the root of the directory tracked by dirstate file; root is the root of the directory tracked by
the dirstate. the dirstate.
""" """
# TODO: all these private methods and attributes should be made # TODO: all these private methods and attributes should be made

mercurial/interfaces/repository.py

The index logically consists of: The index logically consists of:
* A mapping between revision numbers and nodes. * A mapping between revision numbers and nodes.
* DAG data (storing and querying the relationship between nodes). * DAG data (storing and querying the relationship between nodes).
* Metadata to facilitate storage. * Metadata to facilitate storage.
""" """
nullid = interfaceutil.Attribute(
"""node for the null revision for use as delta base."""
)
def __len__(): def __len__():
"""Obtain the number of revisions stored for this file.""" """Obtain the number of revisions stored for this file."""
def __iter__(): def __iter__():
"""Iterate over revision numbers for this file.""" """Iterate over revision numbers for this file."""
def hasnode(node): def hasnode(node):
"""Returns a bool indicating if a node is known to this store. """Returns a bool indicating if a node is known to this store.
Returns the binary node of the created revision. Returns the binary node of the created revision.
""" """
class imanifeststorage(interfaceutil.Interface): class imanifeststorage(interfaceutil.Interface):
"""Storage interface for manifest data.""" """Storage interface for manifest data."""
nodeconstants = interfaceutil.Attribute(
"""nodeconstants used by the current repository."""
)
tree = interfaceutil.Attribute( tree = interfaceutil.Attribute(
"""The path to the directory this manifest tracks. """The path to the directory this manifest tracks.
The empty bytestring represents the root manifest. The empty bytestring represents the root manifest.
""" """
) )
index = interfaceutil.Attribute( index = interfaceutil.Attribute(
"""Interface representing a collection of manifest snapshots. """Interface representing a collection of manifest snapshots.
Represents the root manifest in a repository. Represents the root manifest in a repository.
Also serves as a means to access nested tree manifests and to cache Also serves as a means to access nested tree manifests and to cache
tree manifests. tree manifests.
""" """
nodeconstants = interfaceutil.Attribute(
"""nodeconstants used by the current repository."""
)
def __getitem__(node): def __getitem__(node):
"""Obtain a manifest instance for a given binary node. """Obtain a manifest instance for a given binary node.
Equivalent to calling ``self.get('', node)``. Equivalent to calling ``self.get('', node)``.
The returned object conforms to the ``imanifestrevisionstored`` The returned object conforms to the ``imanifestrevisionstored``
interface. interface.
""" """
class ilocalrepositorymain(interfaceutil.Interface): class ilocalrepositorymain(interfaceutil.Interface):
"""Main interface for local repositories. """Main interface for local repositories.
This currently captures the reality of things - not how things should be. This currently captures the reality of things - not how things should be.
""" """
nodeconstants = interfaceutil.Attribute(
"""Constant nodes matching the hash function used by the repository."""
)
nullid = interfaceutil.Attribute(
"""null revision for the hash function used by the repository."""
)
supportedformats = interfaceutil.Attribute( supportedformats = interfaceutil.Attribute(
"""Set of requirements that apply to stream clone. """Set of requirements that apply to stream clone.
This is actually a class attribute and is shared among all instances. This is actually a class attribute and is shared among all instances.
""" """
) )
supported = interfaceutil.Attribute( supported = interfaceutil.Attribute(

mercurial/localrepo.py

import weakref import weakref
from .i18n import _ from .i18n import _
from .node import ( from .node import (
bin, bin,
hex, hex,
nullid, nullid,
nullrev, nullrev,
sha1nodeconstants,
short, short,
) )
from .pycompat import ( from .pycompat import (
delattr, delattr,
getattr, getattr,
) )
from . import ( from . import (
bookmarks, bookmarks,
self.origroot = origroot self.origroot = origroot
# vfs rooted at working directory. # vfs rooted at working directory.
self.wvfs = wdirvfs self.wvfs = wdirvfs
self.root = wdirvfs.base self.root = wdirvfs.base
# vfs rooted at .hg/. Used to access most non-store paths. # vfs rooted at .hg/. Used to access most non-store paths.
self.vfs = hgvfs self.vfs = hgvfs
self.path = hgvfs.base self.path = hgvfs.base
self.requirements = requirements self.requirements = requirements
self.nodeconstants = sha1nodeconstants
self.nullid = self.nodeconstants.nullid
self.supported = supportedrequirements self.supported = supportedrequirements
self.sharedpath = sharedpath self.sharedpath = sharedpath
self.store = store self.store = store
self.cachevfs = cachevfs self.cachevfs = cachevfs
self.wcachevfs = wcachevfs self.wcachevfs = wcachevfs
self.features = features self.features = features
self.filtername = None self.filtername = None
def dirstate(self): def dirstate(self):
return self._makedirstate() return self._makedirstate()
def _makedirstate(self): def _makedirstate(self):
"""Extension point for wrapping the dirstate per-repo.""" """Extension point for wrapping the dirstate per-repo."""
sparsematchfn = lambda: sparse.matcher(self) sparsematchfn = lambda: sparse.matcher(self)
return dirstate.dirstate( return dirstate.dirstate(
self.vfs, self.ui, self.root, self._dirstatevalidate, sparsematchfn self.vfs,
self.ui,
self.root,
self._dirstatevalidate,
sparsematchfn,
self.nodeconstants,
) )
def _dirstatevalidate(self, node): def _dirstatevalidate(self, node):
try: try:
self.changelog.rev(node) self.changelog.rev(node)
return node return node
except error.LookupError: except error.LookupError:
if not self._dirstatevalidatewarned: if not self._dirstatevalidatewarned:

mercurial/manifest.py

return b'', f return b'', f
_noop = lambda s: None _noop = lambda s: None
@interfaceutil.implementer(repository.imanifestdict) @interfaceutil.implementer(repository.imanifestdict)
class treemanifest(object): class treemanifest(object):
def __init__(self, dir=b'', text=b''): def __init__(self, nodeconstants, dir=b'', text=b''):
self._dir = dir self._dir = dir
self.nodeconstants = nodeconstants
self._node = nullid self._node = nullid
self._loadfunc = _noop self._loadfunc = _noop
self._copyfunc = _noop self._copyfunc = _noop
self._dirty = False self._dirty = False
self._dirs = {} self._dirs = {}
self._lazydirs = {} self._lazydirs = {}
# Using _lazymanifest here is a little slower than plain old dicts # Using _lazymanifest here is a little slower than plain old dicts
self._files = {} self._files = {}
def __setitem__(self, f, n): def __setitem__(self, f, n):
assert n is not None assert n is not None
self._load() self._load()
dir, subpath = _splittopdir(f) dir, subpath = _splittopdir(f)
if dir: if dir:
self._loadlazy(dir) self._loadlazy(dir)
if dir not in self._dirs: 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) self._dirs[dir].__setitem__(subpath, n)
else: else:
# manifest nodes are either 20 bytes or 32 bytes, # manifest nodes are either 20 bytes or 32 bytes,
# depending on the hash in use. Assert this as historically # depending on the hash in use. Assert this as historically
# sometimes extra bytes were added. # sometimes extra bytes were added.
assert len(n) in (20, 32) assert len(n) in (20, 32)
self._files[f] = n self._files[f] = n
self._dirty = True self._dirty = True
"""Set the flags (symlink, executable) for path f.""" """Set the flags (symlink, executable) for path f."""
if flags not in _manifestflags: if flags not in _manifestflags:
raise TypeError(b"Invalid manifest flag set.") raise TypeError(b"Invalid manifest flag set.")
self._load() self._load()
dir, subpath = _splittopdir(f) dir, subpath = _splittopdir(f)
if dir: if dir:
self._loadlazy(dir) self._loadlazy(dir)
if dir not in self._dirs: 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) self._dirs[dir].setflag(subpath, flags)
else: else:
self._flags[f] = flags self._flags[f] = flags
self._dirty = True self._dirty = True
def copy(self): def copy(self):
copy = treemanifest(self._dir) copy = treemanifest(self.nodeconstants, self._dir)
copy._node = self._node copy._node = self._node
copy._dirty = self._dirty copy._dirty = self._dirty
if self._copyfunc is _noop: if self._copyfunc is _noop:
def _copyfunc(s): def _copyfunc(s):
self._load() self._load()
s._lazydirs = { s._lazydirs = {
d: (n, r, True) d: (n, r, True)
def _matches_inner(self, match): def _matches_inner(self, match):
if match.always(): if match.always():
return self.copy() return self.copy()
visit = match.visitchildrenset(self._dir[:-1]) visit = match.visitchildrenset(self._dir[:-1])
if visit == b'all': if visit == b'all':
return self.copy() return self.copy()
ret = treemanifest(self._dir) ret = treemanifest(self.nodeconstants, self._dir)
if not visit: if not visit:
return ret return ret
self._load() self._load()
for fn in self._files: for fn in self._files:
# While visitchildrenset *usually* lists only subdirs, this is # While visitchildrenset *usually* lists only subdirs, this is
# actually up to the matcher and may have some files in the set(). # actually up to the matcher and may have some files in the set().
# If visit == 'this', we should obviously look at the files in this # If visit == 'this', we should obviously look at the files in this
the nodeid will be None and the flags will be the empty the nodeid will be None and the flags will be the empty
string. string.
""" """
if match and not match.always(): if match and not match.always():
m1 = self._matches(match) m1 = self._matches(match)
m2 = m2._matches(match) m2 = m2._matches(match)
return m1.diff(m2, clean=clean) return m1.diff(m2, clean=clean)
result = {} result = {}
emptytree = treemanifest() emptytree = treemanifest(self.nodeconstants)
def _iterativediff(t1, t2, stack): def _iterativediff(t1, t2, stack):
"""compares two tree manifests and append new tree-manifests which """compares two tree manifests and append new tree-manifests which
needs to be compared to stack""" needs to be compared to stack"""
if t1._node == t2._node and not t1._dirty and not t2._dirty: if t1._node == t2._node and not t1._dirty and not t2._dirty:
return return
t1._load() t1._load()
t2._load() t2._load()
s._dirty = False s._dirty = False
self._loadfunc = _load_for_read self._loadfunc = _load_for_read
def writesubtrees(self, m1, m2, writesubtree, match): def writesubtrees(self, m1, m2, writesubtree, match):
self._load() # for consistency; should never have any effect here self._load() # for consistency; should never have any effect here
m1._load() m1._load()
m2._load() m2._load()
emptytree = treemanifest() emptytree = treemanifest(self.nodeconstants)
def getnode(m, d): def getnode(m, d):
ld = m._lazydirs.get(d) ld = m._lazydirs.get(d)
if ld: if ld:
return ld[0] return ld[0]
return m._dirs.get(d, emptytree)._node return m._dirs.get(d, emptytree)._node
# let's skip investigating things that `match` says we do not need. # let's skip investigating things that `match` says we do not need.
@interfaceutil.implementer(repository.imanifeststorage) @interfaceutil.implementer(repository.imanifeststorage)
class manifestrevlog(object): class manifestrevlog(object):
"""A revlog that stores manifest texts. This is responsible for caching the """A revlog that stores manifest texts. This is responsible for caching the
full-text manifest contents. full-text manifest contents.
""" """
def __init__( def __init__(
self, self,
nodeconstants,
opener, opener,
tree=b'', tree=b'',
dirlogcache=None, dirlogcache=None,
indexfile=None, indexfile=None,
treemanifest=False, treemanifest=False,
): ):
"""Constructs a new manifest revlog """Constructs a new manifest revlog
`indexfile` - used by extensions to have two manifests at once, like `indexfile` - used by extensions to have two manifests at once, like
when transitioning between flatmanifeset and treemanifests. when transitioning between flatmanifeset and treemanifests.
`treemanifest` - used to indicate this is a tree manifest revlog. Opener `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 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 option takes precedence, so if it is set to True, we ignore whatever
value is passed in to the constructor. value is passed in to the constructor.
""" """
self.nodeconstants = nodeconstants
# During normal operations, we expect to deal with not more than four # During normal operations, we expect to deal with not more than four
# revs at a time (such as during commit --amend). When rebasing large # 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. # stacks of commits, the number can go up, hence the config knob below.
cachesize = 4 cachesize = 4
optiontreemanifest = False optiontreemanifest = False
opts = getattr(opener, 'options', None) opts = getattr(opener, 'options', None)
if opts is not None: if opts is not None:
cachesize = opts.get(b'manifestcachesize', cachesize) cachesize = opts.get(b'manifestcachesize', cachesize)
self._fulltextcache.clear(clear_persisted_data=clear_persisted_data) self._fulltextcache.clear(clear_persisted_data=clear_persisted_data)
self._dirlogcache = {self.tree: self} self._dirlogcache = {self.tree: self}
def dirlog(self, d): def dirlog(self, d):
if d: if d:
assert self._treeondisk assert self._treeondisk
if d not in self._dirlogcache: if d not in self._dirlogcache:
mfrevlog = manifestrevlog( mfrevlog = manifestrevlog(
self.opener, d, self._dirlogcache, treemanifest=self._treeondisk self.nodeconstants,
self.opener,
d,
self._dirlogcache,
treemanifest=self._treeondisk,
) )
self._dirlogcache[d] = mfrevlog self._dirlogcache[d] = mfrevlog
return self._dirlogcache[d] return self._dirlogcache[d]
def add( def add(
self, self,
m, m,
transaction, transaction,
referenced by commits in the repository. referenced by commits in the repository.
In this situation, 'manifest' refers to the abstract concept of a snapshot In this situation, 'manifest' refers to the abstract concept of a snapshot
of the list of files in the given commit. Consumers of the output of this 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 class do not care about the implementation details of the actual manifests
they receive (i.e. tree or flat or lazily loaded, etc).""" they receive (i.e. tree or flat or lazily loaded, etc)."""
def __init__(self, opener, repo, rootstore, narrowmatch): def __init__(self, opener, repo, rootstore, narrowmatch):
self.nodeconstants = repo.nodeconstants
usetreemanifest = False usetreemanifest = False
cachesize = 4 cachesize = 4
opts = getattr(opener, 'options', None) opts = getattr(opener, 'options', None)
if opts is not None: if opts is not None:
usetreemanifest = opts.get(b'treemanifest', usetreemanifest) usetreemanifest = opts.get(b'treemanifest', usetreemanifest)
cachesize = opts.get(b'manifestcachesize', cachesize) cachesize = opts.get(b'manifestcachesize', cachesize)
`verify` - if True an exception will be thrown if the node is not in `verify` - if True an exception will be thrown if the node is not in
the revlog the revlog
""" """
if node in self._dirmancache.get(tree, ()): if node in self._dirmancache.get(tree, ()):
return self._dirmancache[tree][node] return self._dirmancache[tree][node]
if not self._narrowmatch.always(): if not self._narrowmatch.always():
if not self._narrowmatch.visitdir(tree[:-1]): if not self._narrowmatch.visitdir(tree[:-1]):
return excludeddirmanifestctx(tree, node) return excludeddirmanifestctx(self.nodeconstants, tree, node)
if tree: if tree:
if self._rootstore._treeondisk: if self._rootstore._treeondisk:
if verify: if verify:
# Side-effect is LookupError is raised if node doesn't # Side-effect is LookupError is raised if node doesn't
# exist. # exist.
self.getstorage(tree).rev(node) self.getstorage(tree).rev(node)
m = treemanifestctx(self, tree, node) m = treemanifestctx(self, tree, node)
return self.read().find(key) return self.read().find(key)
@interfaceutil.implementer(repository.imanifestrevisionwritable) @interfaceutil.implementer(repository.imanifestrevisionwritable)
class memtreemanifestctx(object): class memtreemanifestctx(object):
def __init__(self, manifestlog, dir=b''): def __init__(self, manifestlog, dir=b''):
self._manifestlog = manifestlog self._manifestlog = manifestlog
self._dir = dir self._dir = dir
self._treemanifest = treemanifest() self._treemanifest = treemanifest(manifestlog.nodeconstants)
def _storage(self): def _storage(self):
return self._manifestlog.getstorage(b'') return self._manifestlog.getstorage(b'')
def copy(self): def copy(self):
memmf = memtreemanifestctx(self._manifestlog, dir=self._dir) memmf = memtreemanifestctx(self._manifestlog, dir=self._dir)
memmf._treemanifest = self._treemanifest.copy() memmf._treemanifest = self._treemanifest.copy()
return memmf return memmf
# self.p1, self.p2 = store.parents(node) # self.p1, self.p2 = store.parents(node)
# rev = store.rev(node) # rev = store.rev(node)
# self.linkrev = store.linkrev(rev) # self.linkrev = store.linkrev(rev)
def _storage(self): def _storage(self):
narrowmatch = self._manifestlog._narrowmatch narrowmatch = self._manifestlog._narrowmatch
if not narrowmatch.always(): if not narrowmatch.always():
if not narrowmatch.visitdir(self._dir[:-1]): if not narrowmatch.visitdir(self._dir[:-1]):
return excludedmanifestrevlog(self._dir) return excludedmanifestrevlog(
self._manifestlog.nodeconstants, self._dir
)
return self._manifestlog.getstorage(self._dir) return self._manifestlog.getstorage(self._dir)
def read(self): def read(self):
if self._data is None: if self._data is None:
store = self._storage() store = self._storage()
if self._node == nullid: if self._node == nullid:
self._data = treemanifest() self._data = treemanifest(self._manifestlog.nodeconstants)
# TODO accessing non-public API # TODO accessing non-public API
elif store._treeondisk: elif store._treeondisk:
m = treemanifest(dir=self._dir) m = treemanifest(self._manifestlog.nodeconstants, dir=self._dir)
def gettext(): def gettext():
return store.revision(self._node) return store.revision(self._node)
def readsubtree(dir, subm): def readsubtree(dir, subm):
# Set verify to False since we need to be able to create # Set verify to False since we need to be able to create
# subtrees for trees that don't exist on disk. # subtrees for trees that don't exist on disk.
return self._manifestlog.get(dir, subm, verify=False).read() return self._manifestlog.get(dir, subm, verify=False).read()
m.read(gettext, readsubtree) m.read(gettext, readsubtree)
m.setnode(self._node) m.setnode(self._node)
self._data = m self._data = m
else: else:
if self._node in store.fulltextcache: if self._node in store.fulltextcache:
text = pycompat.bytestr(store.fulltextcache[self._node]) text = pycompat.bytestr(store.fulltextcache[self._node])
else: else:
text = store.revision(self._node) text = store.revision(self._node)
arraytext = bytearray(text) arraytext = bytearray(text)
store.fulltextcache[self._node] = arraytext 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 return self._data
def node(self): def node(self):
return self._node return self._node
def copy(self): def copy(self):
memmf = memtreemanifestctx(self._manifestlog, dir=self._dir) memmf = memtreemanifestctx(self._manifestlog, dir=self._dir)
r = store.rev(self._node) r = store.rev(self._node)
d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r)) d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r))
return manifestdict(d) return manifestdict(d)
else: else:
# Need to perform a slow delta # Need to perform a slow delta
r0 = store.deltaparent(store.rev(self._node)) r0 = store.deltaparent(store.rev(self._node))
m0 = self._manifestlog.get(self._dir, store.node(r0)).read() m0 = self._manifestlog.get(self._dir, store.node(r0)).read()
m1 = self.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)): for f, ((n0, fl0), (n1, fl1)) in pycompat.iteritems(m0.diff(m1)):
if n1: if n1:
md[f] = n1 md[f] = n1
if fl1: if fl1:
md.setflag(f, fl1) md.setflag(f, fl1)
return md return md
def readfast(self, shallow=False): def readfast(self, shallow=False):
some of the directory revlogs will be excluded from the resulting some of the directory revlogs will be excluded from the resulting
clone. This is a huge storage win for clients, but means we need clone. This is a huge storage win for clients, but means we need
some sort of pseudo-manifest to surface to internals so we can some sort of pseudo-manifest to surface to internals so we can
detect a merge conflict outside the narrowspec. That's what this detect a merge conflict outside the narrowspec. That's what this
class is: it stands in for a directory whose node is known, but class is: it stands in for a directory whose node is known, but
whose contents are unknown. 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 self._node = node
# Add an empty file, which will be included by iterators and such, # Add an empty file, which will be included by iterators and such,
# appearing as the directory itself (i.e. something like "dir/") # appearing as the directory itself (i.e. something like "dir/")
self._files[b''] = node self._files[b''] = node
self._flags[b''] = b't' self._flags[b''] = b't'
# Manifests outside the narrowspec should never be modified, so avoid # Manifests outside the narrowspec should never be modified, so avoid
# copying. This makes a noticeable difference when there are very many # copying. This makes a noticeable difference when there are very many
# directories outside the narrowspec. Also, it makes sense for the copy to # directories outside the narrowspec. Also, it makes sense for the copy to
# be of the same type as the original, which would not happen with the # be of the same type as the original, which would not happen with the
# super type's copy(). # super type's copy().
def copy(self): def copy(self):
return self return self
class excludeddirmanifestctx(treemanifestctx): class excludeddirmanifestctx(treemanifestctx):
"""context wrapper for excludeddir - see that docstring for rationale""" """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._dir = dir
self._node = node self._node = node
def read(self): def read(self):
return excludeddir(self._dir, self._node) return excludeddir(self.nodeconstants, self._dir, self._node)
def write(self, *args): def write(self, *args):
raise error.ProgrammingError( raise error.ProgrammingError(
b'attempt to write manifest from excluded dir %s' % self._dir b'attempt to write manifest from excluded dir %s' % self._dir
) )
class excludedmanifestrevlog(manifestrevlog): class excludedmanifestrevlog(manifestrevlog):
"""Stand-in for excluded treemanifest revlogs. """Stand-in for excluded treemanifest revlogs.
When narrowing is active on a treemanifest repository, we'll have When narrowing is active on a treemanifest repository, we'll have
references to directories we can't see due to the revlog being references to directories we can't see due to the revlog being
skipped. This class exists to conform to the manifestrevlog skipped. This class exists to conform to the manifestrevlog
interface for those directories and proactively prevent writes to interface for those directories and proactively prevent writes to
outside the narrowspec. outside the narrowspec.
""" """
def __init__(self, dir): def __init__(self, nodeconstants, dir):
self.nodeconstants = nodeconstants
self._dir = dir self._dir = dir
def __len__(self): def __len__(self):
raise error.ProgrammingError( raise error.ProgrammingError(
b'attempt to get length of excluded dir %s' % self._dir b'attempt to get length of excluded dir %s' % self._dir
) )
def rev(self, node): def rev(self, node):

mercurial/node.py

# binascii.unhexlify like we used to on Python 2. # binascii.unhexlify like we used to on Python 2.
def bin(s): def bin(s):
try: try:
return binascii.unhexlify(s) return binascii.unhexlify(s)
except binascii.Error as e: except binascii.Error as e:
raise TypeError(e) raise TypeError(e)
def short(node):
return hex(node[:6])
nullrev = -1 nullrev = -1
# pseudo identifier for working directory
# (experimental, so don't add too many dependencies on it)
wdirrev = 0x7FFFFFFF
class sha1nodeconstants(object):
# In hex, this is '0000000000000000000000000000000000000000' # In hex, this is '0000000000000000000000000000000000000000'
nullid = b"\0" * 20 nullid = b"\0" * 20
nullhex = hex(nullid) nullhex = hex(nullid)
# Phony node value to stand-in for new files in some uses of # Phony node value to stand-in for new files in some uses of
# manifests. # manifests.
# In hex, this is '2121212121212121212121212121212121212121' # In hex, this is '2121212121212121212121212121212121212121'
newnodeid = b'!!!!!!!!!!!!!!!!!!!!' newnodeid = b'!!!!!!!!!!!!!!!!!!!!'
# In hex, this is '3030303030303030303030303030306164646564' # In hex, this is '3030303030303030303030303030306164646564'
addednodeid = b'000000000000000added' addednodeid = b'000000000000000added'
# In hex, this is '3030303030303030303030306d6f646966696564' # In hex, this is '3030303030303030303030306d6f646966696564'
modifiednodeid = b'000000000000modified' modifiednodeid = b'000000000000modified'
wdirfilenodeids = {newnodeid, addednodeid, modifiednodeid} wdirfilenodeids = {newnodeid, addednodeid, modifiednodeid}
# pseudo identifiers for working directory # pseudo identifier for working directory
# (they are experimental, so don't add too many dependencies on them) # (experimental, so don't add too many dependencies on it)
wdirrev = 0x7FFFFFFF
# In hex, this is 'ffffffffffffffffffffffffffffffffffffffff' # In hex, this is 'ffffffffffffffffffffffffffffffffffffffff'
wdirid = b"\xff" * 20 wdirid = b"\xff" * 20
wdirhex = hex(wdirid) wdirhex = hex(wdirid)
def short(node): # legacy starting point for porting modules
return hex(node[:6]) nullid = sha1nodeconstants.nullid
nullhex = sha1nodeconstants.nullhex
newnodeid = sha1nodeconstants.newnodeid
addednodeid = sha1nodeconstants.addednodeid
modifiednodeid = sha1nodeconstants.modifiednodeid
wdirfilenodeids = sha1nodeconstants.wdirfilenodeids
wdirid = sha1nodeconstants.wdirid
wdirhex = sha1nodeconstants.wdirhex

mercurial/obsolete.py

# prec: nodeid, predecessors changesets # prec: nodeid, predecessors changesets
# succs: tuple of nodeid, successor changesets (0-N length) # succs: tuple of nodeid, successor changesets (0-N length)
# flag: integer, flag field carrying modifier for the markers (see doc) # flag: integer, flag field carrying modifier for the markers (see doc)
# meta: binary blob in UTF-8, encoded metadata dictionary # meta: binary blob in UTF-8, encoded metadata dictionary
# date: (float, int) tuple, date of marker creation # date: (float, int) tuple, date of marker creation
# parents: (tuple of nodeid) or None, parents of predecessors # parents: (tuple of nodeid) or None, parents of predecessors
# None is used when no data has been recorded # None is used when no data has been recorded
def __init__(self, svfs, defaultformat=_fm1version, readonly=False): def __init__(self, repo, svfs, defaultformat=_fm1version, readonly=False):
# caches for various obsolescence related cache # caches for various obsolescence related cache
self.caches = {} self.caches = {}
self.svfs = svfs self.svfs = svfs
self.repo = repo
self._defaultformat = defaultformat self._defaultformat = defaultformat
self._readonly = readonly self._readonly = readonly
def __iter__(self): def __iter__(self):
return iter(self._all) return iter(self._all)
def __len__(self): def __len__(self):
return len(self._all) return len(self._all)
# read default format for new obsstore. # read default format for new obsstore.
# developer config: format.obsstore-version # developer config: format.obsstore-version
defaultformat = ui.configint(b'format', b'obsstore-version') defaultformat = ui.configint(b'format', b'obsstore-version')
# rely on obsstore class default when possible. # rely on obsstore class default when possible.
kwargs = {} kwargs = {}
if defaultformat is not None: if defaultformat is not None:
kwargs['defaultformat'] = defaultformat kwargs['defaultformat'] = defaultformat
readonly = not isenabled(repo, createmarkersopt) readonly = not isenabled(repo, createmarkersopt)
store = obsstore(repo.svfs, readonly=readonly, **kwargs) store = obsstore(repo, repo.svfs, readonly=readonly, **kwargs)
if store and readonly: if store and readonly:
ui.warn( ui.warn(
_(b'obsolete feature not enabled but %i markers found!\n') _(b'obsolete feature not enabled but %i markers found!\n')
% len(list(store)) % len(list(store))
) )
return store return store

mercurial/revlog.py

# import stuff from node for others to import from revlog # import stuff from node for others to import from revlog
from .node import ( from .node import (
bin, bin,
hex, hex,
nullhex, nullhex,
nullid, nullid,
nullrev, nullrev,
sha1nodeconstants,
short, short,
wdirfilenodeids, wdirfilenodeids,
wdirhex, wdirhex,
wdirid, wdirid,
wdirrev, wdirrev,
) )
from .i18n import _ from .i18n import _
from .pycompat import getattr from .pycompat import getattr
self._inline = versionflags & FLAG_INLINE_DATA self._inline = versionflags & FLAG_INLINE_DATA
# generaldelta implied by version 2 revlogs. # generaldelta implied by version 2 revlogs.
self._generaldelta = True self._generaldelta = True
else: else:
raise error.RevlogError( raise error.RevlogError(
_(b'unknown version (%d) in revlog %s') % (fmt, self.indexfile) _(b'unknown version (%d) in revlog %s') % (fmt, self.indexfile)
) )
self.nodeconstants = sha1nodeconstants
self.nullid = self.nodeconstants.nullid
# sparse-revlog can't be on without general-delta (issue6056) # sparse-revlog can't be on without general-delta (issue6056)
if not self._generaldelta: if not self._generaldelta:
self._sparserevlog = False self._sparserevlog = False
self._storedeltachains = True self._storedeltachains = True
devel_nodemap = ( devel_nodemap = (
self.nodemap_file self.nodemap_file

mercurial/statichttprepo.py

# statichttprepo.py - simple http repository class for mercurial # statichttprepo.py - simple http repository class for mercurial
# #
# This provides read-only repo access to repositories exported via static http # This provides read-only repo access to repositories exported via static http
# #
# Copyright 2005-2007 Matt Mackall <mpm@selenic.com> # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import errno import errno
from .i18n import _ from .i18n import _
from .node import sha1nodeconstants
from . import ( from . import (
branchmap, branchmap,
changelog, changelog,
error, error,
localrepo, localrepo,
manifest, manifest,
namespaces, namespaces,
pathutil, pathutil,
msg = _(b"'%s' does not appear to be an hg repository") % path msg = _(b"'%s' does not appear to be an hg repository") % path
raise error.RepoError(msg) raise error.RepoError(msg)
supportedrequirements = localrepo.gathersupportedrequirements(ui) supportedrequirements = localrepo.gathersupportedrequirements(ui)
localrepo.ensurerequirementsrecognized( localrepo.ensurerequirementsrecognized(
requirements, supportedrequirements requirements, supportedrequirements
) )
localrepo.ensurerequirementscompatible(ui, requirements) localrepo.ensurerequirementscompatible(ui, requirements)
self.nodeconstants = sha1nodeconstants
self.nullid = self.nodeconstants.nullid
# setup store # setup store
self.store = localrepo.makestore(requirements, self.path, vfsclass) self.store = localrepo.makestore(requirements, self.path, vfsclass)
self.spath = self.store.path self.spath = self.store.path
self.svfs = self.store.opener self.svfs = self.store.opener
self.sjoin = self.store.join self.sjoin = self.store.join
self._filecache = {} self._filecache = {}
self.requirements = requirements self.requirements = requirements
rootmanifest = manifest.manifestrevlog(self.svfs) rootmanifest = manifest.manifestrevlog(self.nodeconstants, self.svfs)
self.manifestlog = manifest.manifestlog( self.manifestlog = manifest.manifestlog(
self.svfs, self, rootmanifest, self.narrowmatch() self.svfs, self, rootmanifest, self.narrowmatch()
) )
self.changelog = changelog.changelog(self.svfs) self.changelog = changelog.changelog(self.svfs)
self._tags = None self._tags = None
self.nodetagscache = None self.nodetagscache = None
self._branchcaches = branchmap.BranchMapCache() self._branchcaches = branchmap.BranchMapCache()
self._revbranchcache = None self._revbranchcache = None

mercurial/store.py

visit.append(fp) visit.append(fp)
l.sort() l.sort()
return l return l
def changelog(self, trypending): def changelog(self, trypending):
return changelog.changelog(self.vfs, trypending=trypending) return changelog.changelog(self.vfs, trypending=trypending)
def manifestlog(self, repo, storenarrowmatch): def manifestlog(self, repo, storenarrowmatch):
rootstore = manifest.manifestrevlog(self.vfs) rootstore = manifest.manifestrevlog(repo.nodeconstants, self.vfs)
return manifest.manifestlog(self.vfs, repo, rootstore, storenarrowmatch) return manifest.manifestlog(self.vfs, repo, rootstore, storenarrowmatch)
def datafiles(self, matcher=None): def datafiles(self, matcher=None):
return self._walk(b'data', True) + self._walk(b'meta', True) return self._walk(b'data', True) + self._walk(b'meta', True)
def topfiles(self): def topfiles(self):
# yield manifest before changelog # yield manifest before changelog
return reversed(self._walk(b'', False)) return reversed(self._walk(b'', False))

mercurial/unionrepo.py

linkmapper = None linkmapper = None
changelog2 = changelog.changelog(opener2) changelog2 = changelog.changelog(opener2)
unionrevlog.__init__( unionrevlog.__init__(
self, opener, self.indexfile, changelog2, linkmapper self, opener, self.indexfile, changelog2, linkmapper
) )
class unionmanifest(unionrevlog, manifest.manifestrevlog): class unionmanifest(unionrevlog, manifest.manifestrevlog):
def __init__(self, opener, opener2, linkmapper): def __init__(self, nodeconstants, opener, opener2, linkmapper):
manifest.manifestrevlog.__init__(self, opener) manifest.manifestrevlog.__init__(self, nodeconstants, opener)
manifest2 = manifest.manifestrevlog(opener2) manifest2 = manifest.manifestrevlog(nodeconstants, opener2)
unionrevlog.__init__( unionrevlog.__init__(
self, opener, self.indexfile, manifest2, linkmapper self, opener, self.indexfile, manifest2, linkmapper
) )
class unionfilelog(filelog.filelog): class unionfilelog(filelog.filelog):
def __init__(self, opener, path, opener2, linkmapper, repo): def __init__(self, opener, path, opener2, linkmapper, repo):
filelog.filelog.__init__(self, opener, path) filelog.filelog.__init__(self, opener, path)
@localrepo.unfilteredpropertycache @localrepo.unfilteredpropertycache
def changelog(self): def changelog(self):
return unionchangelog(self.svfs, self.repo2.svfs) return unionchangelog(self.svfs, self.repo2.svfs)
@localrepo.unfilteredpropertycache @localrepo.unfilteredpropertycache
def manifestlog(self): def manifestlog(self):
rootstore = unionmanifest( rootstore = unionmanifest(
self.svfs, self.repo2.svfs, self.unfiltered()._clrev self.nodeconstants,
self.svfs,
self.repo2.svfs,
self.unfiltered()._clrev,
) )
return manifest.manifestlog( return manifest.manifestlog(
self.svfs, self, rootstore, self.narrowmatch() self.svfs, self, rootstore, self.narrowmatch()
) )
def _clrev(self, rev2): def _clrev(self, rev2):
"""map from repo2 changelog rev to temporary rev in self.changelog""" """map from repo2 changelog rev to temporary rev in self.changelog"""
node = self.repo2.changelog.node(rev2) node = self.repo2.changelog.node(rev2)

mercurial/upgrade_utils/engine.py

"""Obtain a revlog from a repo path. """Obtain a revlog from a repo path.
An instance of the appropriate class is returned. An instance of the appropriate class is returned.
""" """
if path == b'00changelog.i': if path == b'00changelog.i':
return changelog.changelog(repo.svfs) return changelog.changelog(repo.svfs)
elif path.endswith(b'00manifest.i'): elif path.endswith(b'00manifest.i'):
mandir = path[: -len(b'00manifest.i')] mandir = path[: -len(b'00manifest.i')]
return manifest.manifestrevlog(repo.svfs, tree=mandir) return manifest.manifestrevlog(
repo.nodeconstants, repo.svfs, tree=mandir
)
else: else:
# reverse of "/".join(("data", path + ".i")) # reverse of "/".join(("data", path + ".i"))
return filelog.filelog(repo.svfs, path[5:-2]) return filelog.filelog(repo.svfs, path[5:-2])
def _copyrevlog(tr, destrepo, oldrl, unencodedname): def _copyrevlog(tr, destrepo, oldrl, unencodedname):
"""copy all relevant files for `oldrl` into `destrepo` store """copy all relevant files for `oldrl` into `destrepo` store

relnotes/next

== Backwards Compatibility Changes == == Backwards Compatibility Changes ==
== Internal API Changes == == Internal API Changes ==
* `nodes.nullid` and related constants are being phased out as part of
the deprecation of SHA1. Repository instances and related classes
provide access via `nodeconstants` and in some cases `nullid` attributes.

tests/simplestorerepo.py

Index data is stored in an ``index`` file using CBOR. Index data is stored in an ``index`` file using CBOR.
Fulltext data is stored in files having names of the node. Fulltext data is stored in files having names of the node.
""" """
_flagserrorclass = simplestoreerror _flagserrorclass = simplestoreerror
def __init__(self, svfs, path): def __init__(self, repo, svfs, path):
self.nullid = repo.nullid
self._repo = repo
self._svfs = svfs self._svfs = svfs
self._path = path self._path = path
self._storepath = b'/'.join([b'data', path]) self._storepath = b'/'.join([b'data', path])
self._indexpath = b'/'.join([self._storepath, b'index']) self._indexpath = b'/'.join([self._storepath, b'index'])
indexdata = self._svfs.tryread(self._indexpath) indexdata = self._svfs.tryread(self._indexpath)
if indexdata: if indexdata:
if not repo.local(): if not repo.local():
return return
if isinstance(repo, bundlerepo.bundlerepository): if isinstance(repo, bundlerepo.bundlerepository):
raise error.Abort(_('cannot use simple store with bundlerepo')) raise error.Abort(_('cannot use simple store with bundlerepo'))
class simplestorerepo(repo.__class__): class simplestorerepo(repo.__class__):
def file(self, f): def file(self, f):
return filestorage(self.svfs, f) return filestorage(repo, self.svfs, f)
repo.__class__ = simplestorerepo repo.__class__ = simplestorerepo
def featuresetup(ui, supported): def featuresetup(ui, supported):
supported.add(REQUIREMENT) supported.add(REQUIREMENT)

tests/test-check-interfaces.py

ziverify.verifyClass(intdirstate.idirstate, dirstate.dirstate) ziverify.verifyClass(intdirstate.idirstate, dirstate.dirstate)
vfs = vfsmod.vfs(b'.') vfs = vfsmod.vfs(b'.')
fl = filelog.filelog(vfs, b'dummy.i') fl = filelog.filelog(vfs, b'dummy.i')
checkzobject(fl, allowextra=True) checkzobject(fl, allowextra=True)
# Conforms to imanifestlog. # Conforms to imanifestlog.
ml = manifest.manifestlog( ml = manifest.manifestlog(
vfs, repo, manifest.manifestrevlog(repo.svfs), repo.narrowmatch() vfs,
repo,
manifest.manifestrevlog(repo.nodeconstants, repo.svfs),
repo.narrowmatch(),
) )
checkzobject(ml) checkzobject(ml)
checkzobject(repo.manifestlog) checkzobject(repo.manifestlog)
# Conforms to imanifestrevision. # Conforms to imanifestrevision.
mctx = ml[repo[0].manifestnode()] mctx = ml[repo[0].manifestnode()]
checkzobject(mctx) checkzobject(mctx)
# Conforms to imanifestrevisionwritable. # Conforms to imanifestrevisionwritable.
checkzobject(mctx.copy()) checkzobject(mctx.copy())
# Conforms to imanifestdict. # Conforms to imanifestdict.
checkzobject(mctx.read()) checkzobject(mctx.read())
mrl = manifest.manifestrevlog(vfs) mrl = manifest.manifestrevlog(repo.nodeconstants, vfs)
checkzobject(mrl) checkzobject(mrl)
ziverify.verifyClass(repository.irevisiondelta, revlog.revlogrevisiondelta) ziverify.verifyClass(repository.irevisiondelta, revlog.revlogrevisiondelta)
rd = revlog.revlogrevisiondelta( rd = revlog.revlogrevisiondelta(
node=b'', node=b'',
p1node=b'', p1node=b'',
p2node=b'', p2node=b'',

tests/test-manifest.py

from __future__ import absolute_import from __future__ import absolute_import
import binascii import binascii
import itertools import itertools
import silenttestrunner import silenttestrunner
import unittest import unittest
import zlib import zlib
from mercurial.node import sha1nodeconstants
from mercurial import ( from mercurial import (
manifest as manifestmod, manifest as manifestmod,
match as matchmod, match as matchmod,
util, util,
) )
EMTPY_MANIFEST = b'' EMTPY_MANIFEST = b''
b'\xac\xbe' b'\xac\xbe'
) )
with self.assertRaises(ValueError): with self.assertRaises(ValueError):
self.parsemanifest(data) self.parsemanifest(data)
class testtreemanifest(unittest.TestCase, basemanifesttests): class testtreemanifest(unittest.TestCase, basemanifesttests):
def parsemanifest(self, text): def parsemanifest(self, text):
return manifestmod.treemanifest(b'', text) return manifestmod.treemanifest(sha1nodeconstants, b'', text)
def testWalkSubtrees(self): def testWalkSubtrees(self):
m = self.parsemanifest(A_DEEPER_MANIFEST) m = self.parsemanifest(A_DEEPER_MANIFEST)
dirs = [s._dir for s in m.walksubtrees()] dirs = [s._dir for s in m.walksubtrees()]
self.assertEqual( self.assertEqual(
sorted( sorted(
[b'', b'a/', b'a/c/', b'a/d/', b'a/b/', b'a/b/c/', b'a/b/d/'] [b'', b'a/', b'a/c/', b'a/d/', b'a/b/', b'a/b/c/', b'a/b/d/']