This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10539

black: make codebase compatible with black v21.4b2 and v20.8b1
ClosedPublic

Authored by spectral on Apr 30 2021, 7:20 PM.

Details

Reviewers
durin42
SimonSapin
Alphare
Group Reviewers
hg-reviewers
Commits
rHGf38bf44e077f: black: make codebase compatible with black v21.4b2 and v20.8b1
Summary

I don't know what exact version of black made it care about these whitespace
differences, but this is the version I got when I just installed it with
pip3 install black.

I'm intentionally not increasing the version of black required, as I don't want
to force everyone to upgrade their version of black, and these fixes are
backwards compatible with black v20.8b1. If there are more issues in the future
and this becomes a maintenance burden I may do so in a future change.

Tested with both versions of black (I got the older version via
pip3 install black==20.8b1)

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

spectral created this revision.Apr 30 2021, 7:20 PM
SimonSapin accepted this revision.May 3 2021, 2:30 PM
SimonSapin added a subscriber: SimonSapin.

test-check-format.t also fails on my machine after updating black. This patch looks good, it only touches whitespace inside doc-strings

Alphare accepted this revision.May 6 2021, 4:59 AM
This revision is now accepted and ready to land.May 6 2021, 4:59 AM
Alphare added a comment.May 6 2021, 4:59 AM

This will go to the stable branch

Revision Contents
Changeset List

Diff 27616

doc/hgmanpage.py

else: else:
text.append('T}\n') text.append('T}\n')
text.append('_\n') text.append('_\n')
text.append('.TE\n') text.append('.TE\n')
return text return text
class Translator(nodes.NodeVisitor): class Translator(nodes.NodeVisitor):
"""""" """ """
words_and_spaces = re.compile(r'\S+| +|\n') words_and_spaces = re.compile(r'\S+| +|\n')
document_start = """Man page generated from reStructuredText.""" document_start = """Man page generated from reStructuredText."""
def __init__(self, document): def __init__(self, document):
nodes.NodeVisitor.__init__(self, document) nodes.NodeVisitor.__init__(self, document)
self.settings = settings = document.settings self.settings = settings = document.settings
lcode = settings.language_code lcode = settings.language_code

hgext/convert/git.py

name = b'%s%s' % (hgprefix, name[len(gitprefix) :]) name = b'%s%s' % (hgprefix, name[len(gitprefix) :])
bookmarks[name] = rev bookmarks[name] = rev
except Exception: except Exception:
pass pass
return bookmarks return bookmarks
def checkrevformat(self, revstr, mapname=b'splicemap'): def checkrevformat(self, revstr, mapname=b'splicemap'):
""" git revision string is a 40 byte hex """ """git revision string is a 40 byte hex"""
self.checkhexformat(revstr, mapname) self.checkhexformat(revstr, mapname)

hgext/convert/hg.py

return hex(self.repo.lookup(rev)) return hex(self.repo.lookup(rev))
except (error.RepoError, error.LookupError): except (error.RepoError, error.LookupError):
return None return None
def getbookmarks(self): def getbookmarks(self):
return bookmarks.listbookmarks(self.repo) return bookmarks.listbookmarks(self.repo)
def checkrevformat(self, revstr, mapname=b'splicemap'): def checkrevformat(self, revstr, mapname=b'splicemap'):
""" Mercurial, revision string is a 40 byte hex """ """Mercurial, revision string is a 40 byte hex"""
self.checkhexformat(revstr, mapname) self.checkhexformat(revstr, mapname)

hgext/convert/subversion.py

if rev not in self.commits: if rev not in self.commits:
raise error.Abort(_(b'svn: revision %s not found') % revnum) raise error.Abort(_(b'svn: revision %s not found') % revnum)
revcommit = self.commits[rev] revcommit = self.commits[rev]
# caller caches the result, so free it here to release memory # caller caches the result, so free it here to release memory
del self.commits[rev] del self.commits[rev]
return revcommit return revcommit
def checkrevformat(self, revstr, mapname=b'splicemap'): def checkrevformat(self, revstr, mapname=b'splicemap'):
""" fails if revision format does not match the correct format""" """fails if revision format does not match the correct format"""
if not re.match( if not re.match(
br'svn:[0-9a-f]{8,8}-[0-9a-f]{4,4}-' br'svn:[0-9a-f]{8,8}-[0-9a-f]{4,4}-'
br'[0-9a-f]{4,4}-[0-9a-f]{4,4}-[0-9a-f]' br'[0-9a-f]{4,4}-[0-9a-f]{4,4}-[0-9a-f]'
br'{12,12}(.*)@[0-9]+$', br'{12,12}(.*)@[0-9]+$',
revstr, revstr,
): ):
raise error.Abort( raise error.Abort(
_(b'%s entry %s is not a valid revision identifier') _(b'%s entry %s is not a valid revision identifier')

hgext/convert/transport.py

# explicitly initialized. But what we want to do probably # explicitly initialized. But what we want to do probably
# won't work worth a darn against those libraries anyway! # won't work worth a darn against those libraries anyway!
svn.ra.initialize() svn.ra.initialize()
svn_config = None svn_config = None
def _create_auth_baton(pool): def _create_auth_baton(pool):
"""Create a Subversion authentication baton. """ """Create a Subversion authentication baton."""
import svn.client import svn.client
# Give the client context baton a suite of authentication # Give the client context baton a suite of authentication
# providers.h # providers.h
providers = [ providers = [
svn.client.get_simple_provider(pool), svn.client.get_simple_provider(pool),
svn.client.get_username_provider(pool), svn.client.get_username_provider(pool),
svn.client.get_ssl_client_cert_file_provider(pool), svn.client.get_ssl_client_cert_file_provider(pool),

hgext/fsmonitor/pywatchman/__init__.py

else: else:
def log(fmt, *args): def log(fmt, *args):
pass pass
def _win32_strerror(err): def _win32_strerror(err):
""" expand a win32 error code into a human readable message """ """expand a win32 error code into a human readable message"""
# FormatMessage will allocate memory and assign it here # FormatMessage will allocate memory and assign it here
buf = ctypes.c_char_p() buf = ctypes.c_char_p()
FormatMessage( FormatMessage(
FORMAT_MESSAGE_FROM_SYSTEM FORMAT_MESSAGE_FROM_SYSTEM
| FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_ALLOCATE_BUFFER
| FORMAT_MESSAGE_IGNORE_INSERTS, | FORMAT_MESSAGE_IGNORE_INSERTS,
None, None,
def __init__(self, msg, cmd=None): def __init__(self, msg, cmd=None):
super(CommandError, self).__init__( super(CommandError, self).__init__(
"watchman command error: %s" % (msg,), cmd "watchman command error: %s" % (msg,), cmd
) )
class Transport(object): class Transport(object):
""" communication transport to the watchman server """ """communication transport to the watchman server"""
buf = None buf = None
def close(self): def close(self):
""" tear it down """ """tear it down"""
raise NotImplementedError() raise NotImplementedError()
def readBytes(self, size): def readBytes(self, size):
""" read size bytes """ """read size bytes"""
raise NotImplementedError() raise NotImplementedError()
def write(self, buf): def write(self, buf):
""" write some data """ """write some data"""
raise NotImplementedError() raise NotImplementedError()
def setTimeout(self, value): def setTimeout(self, value):
pass pass
def readLine(self): def readLine(self):
"""read a line """read a line
Maintains its own buffer, callers of the transport should not mix Maintains its own buffer, callers of the transport should not mix
result = b"".join(self.buf) result = b"".join(self.buf)
(line, b) = b.split(b"\n", 1) (line, b) = b.split(b"\n", 1)
self.buf = [b] self.buf = [b]
return result + line return result + line
self.buf.append(b) self.buf.append(b)
class Codec(object): class Codec(object):
""" communication encoding for the watchman server """ """communication encoding for the watchman server"""
transport = None transport = None
def __init__(self, transport): def __init__(self, transport):
self.transport = transport self.transport = transport
def receive(self): def receive(self):
raise NotImplementedError() raise NotImplementedError()
def send(self, *args): def send(self, *args):
raise NotImplementedError() raise NotImplementedError()
def setTimeout(self, value): def setTimeout(self, value):
self.transport.setTimeout(value) self.transport.setTimeout(value)
class UnixSocketTransport(Transport): class UnixSocketTransport(Transport):
""" local unix domain socket transport """ """local unix domain socket transport"""
sock = None sock = None
def __init__(self, sockpath, timeout): def __init__(self, sockpath, timeout):
self.sockpath = sockpath self.sockpath = sockpath
self.timeout = timeout self.timeout = timeout
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
err = GetLastError() err = GetLastError()
log("Unexpected error: %s", _win32_strerror(err)) log("Unexpected error: %s", _win32_strerror(err))
return False return False
return GetOverlappedResult(pipe, olap, nbytes, False) return GetOverlappedResult(pipe, olap, nbytes, False)
class WindowsNamedPipeTransport(Transport): class WindowsNamedPipeTransport(Transport):
""" connect to a named pipe """ """connect to a named pipe"""
def __init__(self, sockpath, timeout): def __init__(self, sockpath, timeout):
self.sockpath = sockpath self.sockpath = sockpath
self.timeout = int(math.ceil(timeout * 1000)) self.timeout = int(math.ceil(timeout * 1000))
self._iobuf = None self._iobuf = None
if compat.PYTHON3: if compat.PYTHON3:
sockpath = os.fsencode(sockpath) sockpath = os.fsencode(sockpath)
self._connect() self._connect()
res = self.proc.stdin.write(data) res = self.proc.stdin.write(data)
self.proc.stdin.close() self.proc.stdin.close()
self.closed = True self.closed = True
return res return res
class BserCodec(Codec): class BserCodec(Codec):
""" use the BSER encoding. This is the default, preferred codec """ """use the BSER encoding. This is the default, preferred codec"""
def __init__(self, transport, value_encoding, value_errors): def __init__(self, transport, value_encoding, value_errors):
super(BserCodec, self).__init__(transport) super(BserCodec, self).__init__(transport)
self._value_encoding = value_encoding self._value_encoding = value_encoding
self._value_errors = value_errors self._value_errors = value_errors
def _loads(self, response): def _loads(self, response):
return bser.loads( return bser.loads(
response, response,
False, False,
value_encoding=self._value_encoding, value_encoding=self._value_encoding,
value_errors=self._value_errors, value_errors=self._value_errors,
) )
class Bser2WithFallbackCodec(BserCodec): class Bser2WithFallbackCodec(BserCodec):
""" use BSER v2 encoding """ """use BSER v2 encoding"""
def __init__(self, transport, value_encoding, value_errors): def __init__(self, transport, value_encoding, value_errors):
super(Bser2WithFallbackCodec, self).__init__( super(Bser2WithFallbackCodec, self).__init__(
transport, value_encoding, value_errors transport, value_encoding, value_errors
) )
if compat.PYTHON3: if compat.PYTHON3:
bserv2_key = "required" bserv2_key = "required"
else: else:
class ImmutableBser2Codec(Bser2WithFallbackCodec, ImmutableBserCodec): class ImmutableBser2Codec(Bser2WithFallbackCodec, ImmutableBserCodec):
"""use the BSER encoding, decoding values using the newer """use the BSER encoding, decoding values using the newer
immutable object support""" immutable object support"""
pass pass
class JsonCodec(Codec): class JsonCodec(Codec):
""" Use json codec. This is here primarily for testing purposes """ """Use json codec. This is here primarily for testing purposes"""
json = None json = None
def __init__(self, transport): def __init__(self, transport):
super(JsonCodec, self).__init__(transport) super(JsonCodec, self).__init__(transport)
# optional dep on json, only if JsonCodec is used # optional dep on json, only if JsonCodec is used
import json import json
# containing Unicode strings to Unicode string. Even with (the default) # containing Unicode strings to Unicode string. Even with (the default)
# ensure_ascii=True, dumps returns a Unicode string. # ensure_ascii=True, dumps returns a Unicode string.
if compat.PYTHON3: if compat.PYTHON3:
cmd = cmd.encode("ascii") cmd = cmd.encode("ascii")
self.transport.write(cmd + b"\n") self.transport.write(cmd + b"\n")
class client(object): class client(object):
""" Handles the communication with the watchman service """ """Handles the communication with the watchman service"""
sockpath = None sockpath = None
transport = None transport = None
sendCodec = None sendCodec = None
recvCodec = None recvCodec = None
sendConn = None sendConn = None
recvConn = None recvConn = None
subs = {} # Keyed by subscription name subs = {} # Keyed by subscription name
result = bser.loads(stdout) result = bser.loads(stdout)
if "error" in result: if "error" in result:
raise WatchmanError("get-sockname error: %s" % result["error"]) raise WatchmanError("get-sockname error: %s" % result["error"])
return result["sockname"] return result["sockname"]
def _connect(self): def _connect(self):
""" establish transport connection """ """establish transport connection"""
if self.recvConn: if self.recvConn:
if self.pid != os.getpid(): if self.pid != os.getpid():
raise UseAfterFork( raise UseAfterFork(
"do not re-use a connection after fork; open a new client instead" "do not re-use a connection after fork; open a new client instead"
) )
return return
ee.strerror, ee.strerror,
args, args,
) )
except WatchmanError as ex: except WatchmanError as ex:
ex.setCommand(args) ex.setCommand(args)
raise raise
def capabilityCheck(self, optional=None, required=None): def capabilityCheck(self, optional=None, required=None):
""" Perform a server capability check """ """Perform a server capability check"""
res = self.query( res = self.query(
"version", {"optional": optional or [], "required": required or []} "version", {"optional": optional or [], "required": required or []}
) )
if not self._hasprop(res, "capabilities"): if not self._hasprop(res, "capabilities"):
# Server doesn't support capabilities, so we need to # Server doesn't support capabilities, so we need to
# synthesize the results based on the version # synthesize the results based on the version
capabilities.synthesize(res, optional) capabilities.synthesize(res, optional)
if "error" in res: if "error" in res:
raise CommandError(res["error"]) raise CommandError(res["error"])
return res return res
def setTimeout(self, value): def setTimeout(self, value):
self.recvConn.setTimeout(value) self.recvConn.setTimeout(value)
self.sendConn.setTimeout(value) self.sendConn.setTimeout(value)

hgext/gpg.py

self.path = path self.path = path
self.key = (key and b" --local-user \"%s\"" % key) or b"" self.key = (key and b" --local-user \"%s\"" % key) or b""
def sign(self, data): def sign(self, data):
gpgcmd = b"%s --sign --detach-sign%s" % (self.path, self.key) gpgcmd = b"%s --sign --detach-sign%s" % (self.path, self.key)
return procutil.filter(data, gpgcmd) return procutil.filter(data, gpgcmd)
def verify(self, data, sig): def verify(self, data, sig):
""" returns of the good and bad signatures""" """returns of the good and bad signatures"""
sigfile = datafile = None sigfile = datafile = None
try: try:
# create temporary files # create temporary files
fd, sigfile = pycompat.mkstemp(prefix=b"hg-gpg-", suffix=b".sig") fd, sigfile = pycompat.mkstemp(prefix=b"hg-gpg-", suffix=b".sig")
fp = os.fdopen(fd, 'wb') fp = os.fdopen(fd, 'wb')
fp.write(sig) fp.write(sig)
fp.close() fp.close()
fd, datafile = pycompat.mkstemp(prefix=b"hg-gpg-", suffix=b".txt") fd, datafile = pycompat.mkstemp(prefix=b"hg-gpg-", suffix=b".txt")

hgext/histedit.py

_ctx = scmutil.revsingle(state.repo, ruleid) _ctx = scmutil.revsingle(state.repo, ruleid)
rulehash = _ctx.hex() rulehash = _ctx.hex()
rev = bin(rulehash) rev = bin(rulehash)
except error.RepoLookupError: except error.RepoLookupError:
raise error.ParseError(_(b"invalid changeset %s") % ruleid) raise error.ParseError(_(b"invalid changeset %s") % ruleid)
return cls(state, rev) return cls(state, rev)
def verify(self, prev, expected, seen): def verify(self, prev, expected, seen):
""" Verifies semantic correctness of the rule""" """Verifies semantic correctness of the rule"""
repo = self.repo repo = self.repo
ha = hex(self.node) ha = hex(self.node)
self.node = scmutil.resolvehexnodeidprefix(repo, ha) self.node = scmutil.resolvehexnodeidprefix(repo, ha)
if self.node is None: if self.node is None:
raise error.ParseError(_(b'unknown changeset %s listed') % ha[:12]) raise error.ParseError(_(b'unknown changeset %s listed') % ha[:12])
self._verifynodeconstraints(prev, expected, seen) self._verifynodeconstraints(prev, expected, seen)
def _verifynodeconstraints(self, prev, expected, seen): def _verifynodeconstraints(self, prev, expected, seen):
def commiteditor(self): def commiteditor(self):
return cmdutil.getcommiteditor(edit=True, editform=b'histedit.edit') return cmdutil.getcommiteditor(edit=True, editform=b'histedit.edit')
@action([b'fold', b'f'], _(b'use commit, but combine it with the one above')) @action([b'fold', b'f'], _(b'use commit, but combine it with the one above'))
class fold(histeditaction): class fold(histeditaction):
def verify(self, prev, expected, seen): def verify(self, prev, expected, seen):
""" Verifies semantic correctness of the fold rule""" """Verifies semantic correctness of the fold rule"""
super(fold, self).verify(prev, expected, seen) super(fold, self).verify(prev, expected, seen)
repo = self.repo repo = self.repo
if not prev: if not prev:
c = repo[self.node].p1() c = repo[self.node].p1()
elif not prev.verb in (b'pick', b'base'): elif not prev.verb in (b'pick', b'base'):
return return
else: else:
c = repo[prev.node] c = repo[prev.node]
# surprising happens. # surprising happens.
with repo.vfs(b'histedit-last-edit.txt', b'wb') as f: with repo.vfs(b'histedit-last-edit.txt', b'wb') as f:
f.write(rules) f.write(rules)
return rules return rules
def parserules(rules, state): def parserules(rules, state):
"""Read the histedit rules string and return list of action objects """ """Read the histedit rules string and return list of action objects"""
rules = [ rules = [
l l
for l in (r.strip() for r in rules.splitlines()) for l in (r.strip() for r in rules.splitlines())
if l and not l.startswith(b'#') if l and not l.startswith(b'#')
] ]
actions = [] actions = []
for r in rules: for r in rules:
if b' ' not in r: if b' ' not in r:

hgext/remotenames.py

def __init__(self, kind, repo): def __init__(self, kind, repo):
self.cache = {} self.cache = {}
self.potentialentries = {} self.potentialentries = {}
self._kind = kind # bookmarks or branches self._kind = kind # bookmarks or branches
self._repo = repo self._repo = repo
self.loaded = False self.loaded = False
def _load(self): def _load(self):
""" Read the remotenames file, store entries matching selected kind """ """Read the remotenames file, store entries matching selected kind"""
self.loaded = True self.loaded = True
repo = self._repo repo = self._repo
for node, rpath, rname in logexchange.readremotenamefile( for node, rpath, rname in logexchange.readremotenamefile(
repo, self._kind repo, self._kind
): ):
name = rpath + b'/' + rname name = rpath + b'/' + rname
self.potentialentries[name] = (node, rpath, name) self.potentialentries[name] = (node, rpath, name)
def _resolvedata(self, potentialentry): def _resolvedata(self, potentialentry):
""" Check that the node for potentialentry exists and return it """ """Check that the node for potentialentry exists and return it"""
if not potentialentry in self.potentialentries: if not potentialentry in self.potentialentries:
return None return None
node, remote, name = self.potentialentries[potentialentry] node, remote, name = self.potentialentries[potentialentry]
repo = self._repo repo = self._repo
binnode = bin(node) binnode = bin(node)
# if the node doesn't exist, skip it # if the node doesn't exist, skip it
try: try:
repo.changelog.rev(binnode) repo.changelog.rev(binnode)
val = self._resolvedata(key) val = self._resolvedata(key)
if val is not None: if val is not None:
self.cache[key] = val self.cache[key] = val
return val return val
else: else:
return None return None
def keys(self): def keys(self):
""" Get a list of bookmark or branch names """ """Get a list of bookmark or branch names"""
if not self.loaded: if not self.loaded:
self._load() self._load()
return self.potentialentries.keys() return self.potentialentries.keys()
def iteritems(self): def iteritems(self):
""" Iterate over (name, node) tuples """ """Iterate over (name, node) tuples"""
if not self.loaded: if not self.loaded:
self._load() self._load()
for k, vtup in pycompat.iteritems(self.potentialentries): for k, vtup in pycompat.iteritems(self.potentialentries):
yield (k, [bin(vtup[0])]) yield (k, [bin(vtup[0])])
items = iteritems items = iteritems
class remotenames(object): class remotenames(object):
""" """
This class encapsulates all the remotenames state. It also contains This class encapsulates all the remotenames state. It also contains
methods to access that state in convenient ways. Remotenames are lazy methods to access that state in convenient ways. Remotenames are lazy
loaded. Whenever client code needs to ensure the freshest copy of loaded. Whenever client code needs to ensure the freshest copy of
remotenames, use the `clearnames` method to force an eventual load. remotenames, use the `clearnames` method to force an eventual load.
""" """
def __init__(self, repo, *args): def __init__(self, repo, *args):
self._repo = repo self._repo = repo
self.clearnames() self.clearnames()
def clearnames(self): def clearnames(self):
""" Clear all remote names state """ """Clear all remote names state"""
self.bookmarks = lazyremotenamedict(b"bookmarks", self._repo) self.bookmarks = lazyremotenamedict(b"bookmarks", self._repo)
self.branches = lazyremotenamedict(b"branches", self._repo) self.branches = lazyremotenamedict(b"branches", self._repo)
self._invalidatecache() self._invalidatecache()
def _invalidatecache(self): def _invalidatecache(self):
self._nodetobmarks = None self._nodetobmarks = None
self._nodetobranch = None self._nodetobranch = None
self._hoisttonodes = None self._hoisttonodes = None

mercurial/branchmap.py

self._closedverified = False self._closedverified = False
# branches for which nodes are verified # branches for which nodes are verified
self._verifiedbranches = set() self._verifiedbranches = set()
self._hasnode = hasnode self._hasnode = hasnode
if self._hasnode is None: if self._hasnode is None:
self._hasnode = lambda x: True self._hasnode = lambda x: True
def _verifyclosed(self): def _verifyclosed(self):
""" verify the closed nodes we have """ """verify the closed nodes we have"""
if self._closedverified: if self._closedverified:
return return
for node in self._closednodes: for node in self._closednodes:
if not self._hasnode(node): if not self._hasnode(node):
_unknownnode(node) _unknownnode(node)
self._closedverified = True self._closedverified = True
def _verifybranch(self, branch): def _verifybranch(self, branch):
""" verify head nodes for the given branch. """ """verify head nodes for the given branch."""
if branch not in self._entries or branch in self._verifiedbranches: if branch not in self._entries or branch in self._verifiedbranches:
return return
for n in self._entries[branch]: for n in self._entries[branch]:
if not self._hasnode(n): if not self._hasnode(n):
_unknownnode(n) _unknownnode(n)
self._verifiedbranches.add(branch) self._verifiedbranches.add(branch)
def _verifyall(self): def _verifyall(self):
""" verifies nodes of all the branches """ """verifies nodes of all the branches"""
needverification = set(self._entries.keys()) - self._verifiedbranches needverification = set(self._entries.keys()) - self._verifiedbranches
for b in needverification: for b in needverification:
self._verifybranch(b) self._verifybranch(b)
def __iter__(self): def __iter__(self):
return iter(self._entries) return iter(self._entries)
def __setitem__(self, key, value): def __setitem__(self, key, value):
def iteritems(self): def iteritems(self):
for k, v in pycompat.iteritems(self._entries): for k, v in pycompat.iteritems(self._entries):
self._verifybranch(k) self._verifybranch(k)
yield k, v yield k, v
items = iteritems items = iteritems
def hasbranch(self, label): def hasbranch(self, label):
""" checks whether a branch of this name exists or not """ """checks whether a branch of this name exists or not"""
self._verifybranch(label) self._verifybranch(label)
return label in self._entries return label in self._entries
@classmethod @classmethod
def fromfile(cls, repo): def fromfile(cls, repo):
f = None f = None
try: try:
f = repo.cachevfs(cls._filename(repo)) f = repo.cachevfs(cls._filename(repo))
heads = list(self.iteropen(heads)) heads = list(self.iteropen(heads))
return heads return heads
def iterbranches(self): def iterbranches(self):
for bn, heads in pycompat.iteritems(self): for bn, heads in pycompat.iteritems(self):
yield (bn, heads) + self._branchtip(heads) yield (bn, heads) + self._branchtip(heads)
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._repo,
self._entries, self._entries,
b"couldn't write revision branch cache%s: %s\n" b"couldn't write revision branch cache%s: %s\n"
% (step, stringutil.forcebytestr(inst)) % (step, stringutil.forcebytestr(inst))
) )
finally: finally:
if wlock is not None: if wlock is not None:
wlock.release() wlock.release()
def _writenames(self, repo): def _writenames(self, repo):
""" write the new branch names to revbranchcache """ """write the new branch names to revbranchcache"""
if self._rbcnamescount != 0: if self._rbcnamescount != 0:
f = repo.cachevfs.open(_rbcnames, b'ab') f = repo.cachevfs.open(_rbcnames, b'ab')
if f.tell() == self._rbcsnameslen: if f.tell() == self._rbcsnameslen:
f.write(b'\0') f.write(b'\0')
else: else:
f.close() f.close()
repo.ui.debug(b"%s changed - rewriting it\n" % _rbcnames) repo.ui.debug(b"%s changed - rewriting it\n" % _rbcnames)
self._rbcnamescount = 0 self._rbcnamescount = 0
self._rbcrevslen = 0 self._rbcrevslen = 0
if self._rbcnamescount == 0: if self._rbcnamescount == 0:
# before rewriting names, make sure references are removed # before rewriting names, make sure references are removed
repo.cachevfs.unlinkpath(_rbcrevs, ignoremissing=True) repo.cachevfs.unlinkpath(_rbcrevs, ignoremissing=True)
f = repo.cachevfs.open(_rbcnames, b'wb') f = repo.cachevfs.open(_rbcnames, b'wb')
f.write( f.write(
b'\0'.join( b'\0'.join(
encoding.fromlocal(b) encoding.fromlocal(b)
for b in self._names[self._rbcnamescount :] for b in self._names[self._rbcnamescount :]
) )
) )
self._rbcsnameslen = f.tell() self._rbcsnameslen = f.tell()
f.close() f.close()
self._rbcnamescount = len(self._names) self._rbcnamescount = len(self._names)
def _writerevs(self, repo, start): def _writerevs(self, repo, start):
""" write the new revs to revbranchcache """ """write the new revs to revbranchcache"""
revs = min(len(repo.changelog), len(self._rbcrevs) // _rbcrecsize) revs = min(len(repo.changelog), len(self._rbcrevs) // _rbcrecsize)
with repo.cachevfs.open(_rbcrevs, b'ab') as f: with repo.cachevfs.open(_rbcrevs, b'ab') as f:
if f.tell() != start: if f.tell() != start:
repo.ui.debug( repo.ui.debug(
b"truncating cache/%s to %d\n" % (_rbcrevs, start) b"truncating cache/%s to %d\n" % (_rbcrevs, start)
) )
f.seek(start) f.seek(start)
if f.tell() != start: if f.tell() != start:
start = 0 start = 0
f.seek(start) f.seek(start)
f.truncate() f.truncate()
end = revs * _rbcrecsize end = revs * _rbcrecsize
f.write(self._rbcrevs[start:end]) f.write(self._rbcrevs[start:end])
self._rbcrevslen = revs self._rbcrevslen = revs

mercurial/bundle2.py

b'negative bundle param size: %i' % paramssize b'negative bundle param size: %i' % paramssize
) )
if paramssize: if paramssize:
params = self._readexact(paramssize) params = self._readexact(paramssize)
params = self._processallparams(params) params = self._processallparams(params)
return params return params
def _processallparams(self, paramsblock): def _processallparams(self, paramsblock):
"""""" """ """
params = util.sortdict() params = util.sortdict()
for p in paramsblock.split(b' '): for p in paramsblock.split(b' '):
p = p.split(b'=', 1) p = p.split(b'=', 1)
p = [urlreq.unquote(i) for i in p] p = [urlreq.unquote(i) for i in p]
if len(p) < 2: if len(p) < 2:
p.append(None) p.append(None)
self._processparam(*p) self._processparam(*p)
params[p[0]] = p[1] params[p[0]] = p[1]

mercurial/cmdutil.py

if opts.get(b'currentuser'): if opts.get(b'currentuser'):
opts[b'user'] = ui.username() opts[b'user'] = ui.username()
return datemaydiffer return datemaydiffer
def checknotesize(ui, opts): def checknotesize(ui, opts):
""" make sure note is of valid format """ """make sure note is of valid format"""
note = opts.get(b'note') note = opts.get(b'note')
if not note: if not note:
return return
if len(note) > 255: if len(note) > 255:
raise error.InputError(_(b"cannot store a note of more than 255 bytes")) raise error.InputError(_(b"cannot store a note of more than 255 bytes"))
if b'\n' in note: if b'\n' in note:
if choice: if choice:
return list(choice.values())[0] return list(choice.values())[0]
raise error.UnknownCommand(cmd, allcmds) raise error.UnknownCommand(cmd, allcmds)
def changebranch(ui, repo, revs, label, opts): def changebranch(ui, repo, revs, label, opts):
""" Change the branch name of given revs to label """ """Change the branch name of given revs to label"""
with repo.wlock(), repo.lock(), repo.transaction(b'branches'): with repo.wlock(), repo.lock(), repo.transaction(b'branches'):
# abort in case of uncommitted merge or dirty wdir # abort in case of uncommitted merge or dirty wdir
bailifchanged(repo) bailifchanged(repo)
revs = scmutil.revrange(repo, revs) revs = scmutil.revrange(repo, revs)
if not revs: if not revs:
raise error.InputError(b"empty revision set") raise error.InputError(b"empty revision set")
roots = repo.revs(b'roots(%ld)', revs) roots = repo.revs(b'roots(%ld)', revs)
if st.modified or st.added or st.removed or st.deleted: if st.modified or st.added or st.removed or st.deleted:
raise error.StateError(_(b'uncommitted changes'), hint=hint) raise error.StateError(_(b'uncommitted changes'), hint=hint)
ctx = repo[None] ctx = repo[None]
for s in sorted(ctx.substate): for s in sorted(ctx.substate):
ctx.sub(s).bailifchanged(hint=hint) ctx.sub(s).bailifchanged(hint=hint)
def logmessage(ui, opts): def logmessage(ui, opts):
""" get the log message according to -m and -l option """ """get the log message according to -m and -l option"""
check_at_most_one_arg(opts, b'message', b'logfile') check_at_most_one_arg(opts, b'message', b'logfile')
message = opts.get(b'message') message = opts.get(b'message')
logfile = opts.get(b'logfile') logfile = opts.get(b'logfile')
if not message and logfile: if not message and logfile:
try: try:
try: try:
return graftstate.read() return graftstate.read()
except error.CorruptedState: except error.CorruptedState:
nodes = repo.vfs.read(b'graftstate').splitlines() nodes = repo.vfs.read(b'graftstate').splitlines()
return {b'nodes': nodes} return {b'nodes': nodes}
def hgabortgraft(ui, repo): def hgabortgraft(ui, repo):
""" abort logic for aborting graft using 'hg abort'""" """abort logic for aborting graft using 'hg abort'"""
with repo.wlock(): with repo.wlock():
graftstate = statemod.cmdstate(repo, b'graftstate') graftstate = statemod.cmdstate(repo, b'graftstate')
return abortgraft(ui, repo, graftstate) return abortgraft(ui, repo, graftstate)

mercurial/commandserver.py

# were lost, the client wouldn't be able to continue processing. # were lost, the client wouldn't be able to continue processing.
self.cresult.write(struct.pack(b'>i', int(ret))) self.cresult.write(struct.pack(b'>i', int(ret)))
finally: finally:
# restore old cwd # restore old cwd
if b'--cwd' in args: if b'--cwd' in args:
os.chdir(self.cwd) os.chdir(self.cwd)
def getencoding(self): def getencoding(self):
""" writes the current encoding to the result channel """ """writes the current encoding to the result channel"""
self.cresult.write(encoding.encoding) self.cresult.write(encoding.encoding)
def serveone(self): def serveone(self):
cmd = self.client.readline()[:-1] cmd = self.client.readline()[:-1]
if cmd: if cmd:
handler = self.capabilities.get(cmd) handler = self.capabilities.get(cmd)
if handler: if handler:
handler(self) handler(self)

mercurial/crecord.py

def lastchild(self): def lastchild(self):
"""return the last child of this item, if one exists. otherwise """return the last child of this item, if one exists. otherwise
None.""" None."""
# hunk-lines don't have children # hunk-lines don't have children
return None return None
class uihunk(patchnode): class uihunk(patchnode):
"""ui patch hunk, wraps a hunk and keep track of ui behavior """ """ui patch hunk, wraps a hunk and keep track of ui behavior"""
maxcontext = 3 maxcontext = 3
def __init__(self, hunk, header): def __init__(self, hunk, header):
self._hunk = hunk self._hunk = hunk
self.changedlines = [uihunkline(line, self) for line in hunk.hunk] self.changedlines = [uihunkline(line, self) for line in hunk.hunk]
self.header = header self.header = header
# used at end for detecting how many removed lines were un-applied # used at end for detecting how many removed lines were un-applied

mercurial/debugcommands.py

if o: if o:
ui.write(_(b"%s renamed from %s:%s\n") % (rel, o[0], hex(o[1]))) ui.write(_(b"%s renamed from %s:%s\n") % (rel, o[0], hex(o[1])))
else: else:
ui.write(_(b"%s not renamed\n") % rel) ui.write(_(b"%s not renamed\n") % rel)
@command(b'debugrequires|debugrequirements', [], b'') @command(b'debugrequires|debugrequirements', [], b'')
def debugrequirements(ui, repo): def debugrequirements(ui, repo):
""" print the current repo requirements """ """print the current repo requirements"""
for r in sorted(repo.requirements): for r in sorted(repo.requirements):
ui.write(b"%s\n" % r) ui.write(b"%s\n" % r)
@command( @command(
b'debugrevlog', b'debugrevlog',
cmdutil.debugrevlogopts + [(b'd', b'dump', False, _(b'dump index data'))], cmdutil.debugrevlogopts + [(b'd', b'dump', False, _(b'dump index data'))],
_(b'-c|-m|FILE'), _(b'-c|-m|FILE'),

mercurial/mail.py

if not procutil.findexe(method): if not procutil.findexe(method):
raise error.Abort( raise error.Abort(
_(b'%r specified as email transport, but not in PATH') % method _(b'%r specified as email transport, but not in PATH') % method
) )
def codec2iana(cs): def codec2iana(cs):
# type: (str) -> str # type: (str) -> str
'''''' ''' '''
cs = email.charset.Charset(cs).input_charset.lower() cs = email.charset.Charset(cs).input_charset.lower()
# "latin1" normalizes to "iso8859-1", standard calls for "iso-8859-1" # "latin1" normalizes to "iso8859-1", standard calls for "iso-8859-1"
if cs.startswith("iso") and not cs.startswith("iso-"): if cs.startswith("iso") and not cs.startswith("iso-"):
return "iso-" + cs[3:] return "iso-" + cs[3:]
return cs return cs

mercurial/mergestate.py

for f, entry in pycompat.iteritems(self._state): for f, entry in pycompat.iteritems(self._state):
if entry[0] in ( if entry[0] in (
MERGE_RECORD_UNRESOLVED, MERGE_RECORD_UNRESOLVED,
MERGE_RECORD_UNRESOLVED_PATH, MERGE_RECORD_UNRESOLVED_PATH,
): ):
yield f yield f
def allextras(self): def allextras(self):
""" return all extras information stored with the mergestate """ """return all extras information stored with the mergestate"""
return self._stateextras return self._stateextras
def extras(self, filename): def extras(self, filename):
""" return extras stored with the mergestate for the given filename """ """return extras stored with the mergestate for the given filename"""
return self._stateextras[filename] return self._stateextras[filename]
def _resolve(self, preresolve, dfile, wctx): def _resolve(self, preresolve, dfile, wctx):
"""rerun merge process for file path `dfile`. """rerun merge process for file path `dfile`.
Returns whether the merge was completed and the return value of merge Returns whether the merge was completed and the return value of merge
obtained from filemerge._filemerge(). obtained from filemerge._filemerge().
""" """
if self[dfile] in ( if self[dfile] in (

mercurial/revlogutils/nodemap.py

notr = _NoTransaction() notr = _NoTransaction()
persist_nodemap(notr, revlog) persist_nodemap(notr, revlog)
for k in sorted(notr._postclose): for k in sorted(notr._postclose):
notr._postclose[k](None) notr._postclose[k](None)
def delete_nodemap(tr, repo, revlog): def delete_nodemap(tr, repo, revlog):
""" Delete nodemap data on disk for a given revlog""" """Delete nodemap data on disk for a given revlog"""
if revlog.nodemap_file is None: if revlog.nodemap_file is None:
msg = "calling persist nodemap on a revlog without the feature enabled" msg = "calling persist nodemap on a revlog without the feature enabled"
raise error.ProgrammingError(msg) raise error.ProgrammingError(msg)
repo.svfs.unlink(revlog.nodemap_file) repo.svfs.unlink(revlog.nodemap_file)
def persist_nodemap(tr, revlog, pending=False, force=False): def persist_nodemap(tr, revlog, pending=False, force=False):
"""Write nodemap data on disk for a given revlog""" """Write nodemap data on disk for a given revlog"""

mercurial/scmutil.py

wc.add(r) wc.add(r)
else: else:
store.add(r) store.add(r)
return wc, store return wc, store
return requirements, None return requirements, None
def istreemanifest(repo): def istreemanifest(repo):
""" returns whether the repository is using treemanifest or not """ """returns whether the repository is using treemanifest or not"""
return requirementsmod.TREEMANIFEST_REQUIREMENT in repo.requirements return requirementsmod.TREEMANIFEST_REQUIREMENT in repo.requirements
def writereporequirements(repo, requirements=None): def writereporequirements(repo, requirements=None):
"""writes requirements for the repo """writes requirements for the repo
Requirements are written to .hg/requires and .hg/store/requires based Requirements are written to .hg/requires and .hg/store/requires based
on whether share-safe mode is enabled and which requirements are wdir on whether share-safe mode is enabled and which requirements are wdir

mercurial/state.py

def msg(self): def msg(self):
"""returns the status message corresponding to the command""" """returns the status message corresponding to the command"""
if not self._cmdmsg: if not self._cmdmsg:
return _(b'%s in progress') % (self._opname) return _(b'%s in progress') % (self._opname)
return self._cmdmsg return self._cmdmsg
def continuemsg(self): def continuemsg(self):
""" returns appropriate continue message corresponding to command""" """returns appropriate continue message corresponding to command"""
return _(b'hg %s --continue') % (self._opname) return _(b'hg %s --continue') % (self._opname)
def isunfinished(self, repo): def isunfinished(self, repo):
"""determines whether a multi-step operation is in progress """determines whether a multi-step operation is in progress
or not or not
""" """
if self._opname == b'merge': if self._opname == b'merge':
return len(repo[None].parents()) > 1 return len(repo[None].parents()) > 1

mercurial/store.py

b"use 'hg debugrebuildfncache' to " b"use 'hg debugrebuildfncache' to "
b"rebuild the fncache" b"rebuild the fncache"
), ),
) )
self._checkentries(fp, warn) self._checkentries(fp, warn)
fp.close() fp.close()
def _checkentries(self, fp, warn): def _checkentries(self, fp, warn):
""" make sure there is no empty string in entries """ """make sure there is no empty string in entries"""
if b'' in self.entries: if b'' in self.entries:
fp.seek(0) fp.seek(0)
for n, line in enumerate(util.iterfile(fp)): for n, line in enumerate(util.iterfile(fp)):
if not line.rstrip(b'\n'): if not line.rstrip(b'\n'):
t = _(b'invalid entry in fncache, line %d') % (n + 1) t = _(b'invalid entry in fncache, line %d') % (n + 1)
if warn: if warn:
warn(t + b'\n') warn(t + b'\n')
else: else:

mercurial/upgrade_utils/actions.py

self.ui.write((b' - %s\n' % r)) self.ui.write((b' - %s\n' % r))
self.ui.write((b'\n')) self.ui.write((b'\n'))
def print_unused_optimizations(self): def print_unused_optimizations(self):
for i in self.unused_optimizations: for i in self.unused_optimizations:
self.ui.status(_(b'%s\n %s\n\n') % (i.name, i.description)) self.ui.status(_(b'%s\n %s\n\n') % (i.name, i.description))
def has_upgrade_action(self, name): def has_upgrade_action(self, name):
""" Check whether the upgrade operation will perform this action """ """Check whether the upgrade operation will perform this action"""
return name in self._upgrade_actions_names return name in self._upgrade_actions_names
def print_post_op_messages(self): def print_post_op_messages(self):
""" print post upgrade operation warning messages """ """print post upgrade operation warning messages"""
for a in self.upgrade_actions: for a in self.upgrade_actions:
if a.postupgrademessage is not None: if a.postupgrademessage is not None:
self.ui.warn(b'%s\n' % a.postupgrademessage) self.ui.warn(b'%s\n' % a.postupgrademessage)
for a in self.removed_actions: for a in self.removed_actions:
if a.postdowngrademessage is not None: if a.postdowngrademessage is not None:
self.ui.warn(b'%s\n' % a.postdowngrademessage) self.ui.warn(b'%s\n' % a.postdowngrademessage)

mercurial/upgrade_utils/engine.py

tr, tr,
old_revlog, old_revlog,
rl_type, rl_type,
unencoded, unencoded,
upgrade_op, upgrade_op,
sidedatacompanion, sidedatacompanion,
oncopiedrevision, oncopiedrevision,
): ):
""" returns the new revlog object created""" """returns the new revlog object created"""
newrl = None newrl = None
if matchrevlog(upgrade_op.revlogs_to_process, rl_type): if matchrevlog(upgrade_op.revlogs_to_process, rl_type):
ui.note( ui.note(
_(b'cloning %d revisions from %s\n') % (len(old_revlog), unencoded) _(b'cloning %d revisions from %s\n') % (len(old_revlog), unencoded)
) )
newrl = _revlogfrompath(dstrepo, rl_type, unencoded) newrl = _revlogfrompath(dstrepo, rl_type, unencoded)
old_revlog.clone( old_revlog.clone(
tr, tr,

mercurial/util.py

statislink = platform.statislink statislink = platform.statislink
umask = platform.umask umask = platform.umask
unlink = platform.unlink unlink = platform.unlink
username = platform.username username = platform.username
def setumask(val): def setumask(val):
# type: (int) -> None # type: (int) -> None
''' updates the umask. used by chg server ''' '''updates the umask. used by chg server'''
if pycompat.iswindows: if pycompat.iswindows:
return return
os.umask(val) os.umask(val)
global umask global umask
platform.umask = umask = val & 0o777 platform.umask = umask = val & 0o777
# small compat layer # small compat layer