This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5993

cleanup: use () to wrap long lines instead of \
ClosedPublic

Authored by durin42 on Feb 20 2019, 7:33 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGaaad36b88298: cleanup: use () to wrap long lines instead of \
Summary

This is a little less brittle, and often helps indentation. In a
surprising number of cases the entire cleanup was deleting the \, as
the expression was *already* parenthesized in a workable way.

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

durin42 created this revision.Feb 20 2019, 7:33 PM
durin42 updated this revision to Diff 14173.Feb 21 2019, 12:49 PM
Closed by commit rHGaaad36b88298: cleanup: use () to wrap long lines instead of \ (authored by durin42). · Explain WhyFeb 21 2019, 4:28 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 14178

contrib/debugshell.py

cl = repo.changelog cl = repo.changelog
mf = repo.manifestlog mf = repo.manifestlog
cl, mf # use variables to appease pyflakes cl, mf # use variables to appease pyflakes
IPython.embed() IPython.embed()
@command('debugshell|dbsh', []) @command('debugshell|dbsh', [])
def debugshell(ui, repo, **opts): def debugshell(ui, repo, **opts):
bannermsg = "loaded repo : %s\n" \ bannermsg = ("loaded repo : %s\n"
"using source: %s" % (repo.root, "using source: %s" % (repo.root,
mercurial.__path__[0]) mercurial.__path__[0]))
pdbmap = { pdbmap = {
'pdb' : 'code', 'pdb' : 'code',
'ipdb' : 'IPython' 'ipdb' : 'IPython'
} }
debugger = ui.config("ui", "debugger") debugger = ui.config("ui", "debugger")
if not debugger: if not debugger:

contrib/packaging/hg-docker

'-', '-',
] ]
print('executing: %r' % args) print('executing: %r' % args)
p = subprocess.Popen(args, stdin=subprocess.PIPE) p = subprocess.Popen(args, stdin=subprocess.PIPE)
p.communicate(input=dockerfile) p.communicate(input=dockerfile)
if p.returncode: if p.returncode:
raise subprocess.CalledProcessException( raise subprocess.CalledProcessException(
p.returncode, 'failed to build docker image: %s %s' \ p.returncode, 'failed to build docker image: %s %s'
% (p.stdout, p.stderr)) % (p.stdout, p.stderr))
def command_build(args): def command_build(args):
build_args = [] build_args = []
for arg in args.build_arg: for arg in args.build_arg:
k, v = arg.split('=', 1) k, v = arg.split('=', 1)
build_args.append((k.encode('utf-8'), v.encode('utf-8'))) build_args.append((k.encode('utf-8'), v.encode('utf-8')))

hgext/acl.py

for ug in usersorgroups.replace(',', ' ').split(): for ug in usersorgroups.replace(',', ' ').split():
if ug.startswith('!'): if ug.startswith('!'):
# Test for excluded user or group. Format: # Test for excluded user or group. Format:
# if ug is a user name: !username # if ug is a user name: !username
# if ug is a group name: !@groupname # if ug is a group name: !@groupname
ug = ug[1:] ug = ug[1:]
if not ug.startswith('@') and user != ug \ if (not ug.startswith('@') and user != ug
or ug.startswith('@') and user not in _getusers(ui, ug[1:]): or ug.startswith('@') and user not in _getusers(ui, ug[1:])):
return True return True
# Test for user or group. Format: # Test for user or group. Format:
# if ug is a user name: username # if ug is a user name: username
# if ug is a group name: @groupname # if ug is a group name: @groupname
elif user == ug \ elif (user == ug
or ug.startswith('@') and user in _getusers(ui, ug[1:]): or ug.startswith('@') and user in _getusers(ui, ug[1:])):
return True return True
return False return False
def buildmatch(ui, repo, user, key): def buildmatch(ui, repo, user, key):
'''return tuple of (match function, list enabled).''' '''return tuple of (match function, list enabled).'''
if not ui.has_section(key): if not ui.has_section(key):
ui.debug('acl: %s not enabled\n' % key) ui.debug('acl: %s not enabled\n' % key)

hgext/bugzilla.py

(bugid, userid, now, self.longdesc_id)) (bugid, userid, now, self.longdesc_id))
self.conn.commit() self.conn.commit()
class bzmysql_2_18(bzmysql): class bzmysql_2_18(bzmysql):
'''support for bugzilla 2.18 series.''' '''support for bugzilla 2.18 series.'''
def __init__(self, ui): def __init__(self, ui):
bzmysql.__init__(self, ui) bzmysql.__init__(self, ui)
self.default_notify = \ self.default_notify = (
"cd %(bzdir)s && perl -T contrib/sendbugmail.pl %(id)s %(user)s" "cd %(bzdir)s && perl -T contrib/sendbugmail.pl %(id)s %(user)s")
class bzmysql_3_0(bzmysql_2_18): class bzmysql_3_0(bzmysql_2_18):
'''support for bugzilla 3.0 series.''' '''support for bugzilla 3.0 series.'''
def __init__(self, ui): def __init__(self, ui):
bzmysql_2_18.__init__(self, ui) bzmysql_2_18.__init__(self, ui)
def get_longdesc_id(self): def get_longdesc_id(self):

hgext/convert/cvsps.py

p = candidate p = candidate
c.parents = [] c.parents = []
if p is not None: if p is not None:
p = changesets[p] p = changesets[p]
# Ensure no changeset has a synthetic changeset as a parent. # Ensure no changeset has a synthetic changeset as a parent.
while p.synthetic: while p.synthetic:
assert len(p.parents) <= 1, \ assert len(p.parents) <= 1, (
_('synthetic changeset cannot have multiple parents') _('synthetic changeset cannot have multiple parents'))
if p.parents: if p.parents:
p = p.parents[0] p = p.parents[0]
else: else:
p = None p = None
break break
if p is not None: if p is not None:
c.parents.append(p) c.parents.append(p)
fn, fn,
'.'.join([b"%d" % x for x in f.parent]) or 'INITIAL', '.'.join([b"%d" % x for x in f.parent]) or 'INITIAL',
'.'.join([(b"%d" % x) for x in f.revision]), '.'.join([(b"%d" % x) for x in f.revision]),
['', '(DEAD)'][f.dead])) ['', '(DEAD)'][f.dead]))
ui.write('\n') ui.write('\n')
# have we seen the start tag? # have we seen the start tag?
if revisions and off: if revisions and off:
if revisions[0] == (b"%d" % cs.id) or \ if (revisions[0] == (b"%d" % cs.id) or
revisions[0] in cs.tags: revisions[0] in cs.tags):
off = False off = False
# see if we reached the end tag # see if we reached the end tag
if len(revisions) > 1 and not off: if len(revisions) > 1 and not off:
if revisions[1] == (b"%d" % cs.id) or \ if (revisions[1] == (b"%d" % cs.id) or
revisions[1] in cs.tags: revisions[1] in cs.tags):
break break

hgext/convert/git.py

rev=version, rev=version,
extra=extra, extra=extra,
saverev=saverev) saverev=saverev)
return c return c
def numcommits(self): def numcommits(self):
output, ret = self.gitrunlines('rev-list', '--all') output, ret = self.gitrunlines('rev-list', '--all')
if ret: if ret:
raise error.Abort(_('cannot retrieve number of commits in %s') \ raise error.Abort(_('cannot retrieve number of commits in %s')
% self.path) % self.path)
return len(output) return len(output)
def gettags(self): def gettags(self):
tags = {} tags = {}
alltags = {} alltags = {}
output, status = self.gitrunlines('ls-remote', '--tags', self.path) output, status = self.gitrunlines('ls-remote', '--tags', self.path)

hgext/convert/p4.py

copiedfiles.append(filename) copiedfiles.append(filename)
localname[oldname] = filename localname[oldname] = filename
i += 1 i += 1
# Collect information about copied files # Collect information about copied files
for filename in copiedfiles: for filename in copiedfiles:
oldname = depotname[filename] oldname = depotname[filename]
flcmd = 'p4 -G filelog %s' \ flcmd = ('p4 -G filelog %s'
% procutil.shellquote(oldname) % procutil.shellquote(oldname))
flstdout = procutil.popen(flcmd, mode='rb') flstdout = procutil.popen(flcmd, mode='rb')
copiedfilename = None copiedfilename = None
for d in loaditer(flstdout): for d in loaditer(flstdout):
copiedoldname = None copiedoldname = None
i = 0 i = 0
while ("change%d" % i) in d: while ("change%d" % i) in d:
@util.propertycache @util.propertycache
def depotname(self): def depotname(self):
return self._parse_once['depotname'] return self._parse_once['depotname']
def getheads(self): def getheads(self):
return self.heads return self.heads
def getfile(self, name, rev): def getfile(self, name, rev):
cmd = 'p4 -G print %s' \ cmd = ('p4 -G print %s'
% procutil.shellquote("%s#%s" % (self.depotname[name], rev)) % procutil.shellquote("%s#%s" % (self.depotname[name], rev)))
lasterror = None lasterror = None
while True: while True:
stdout = procutil.popen(cmd, mode='rb') stdout = procutil.popen(cmd, mode='rb')
mode = None mode = None
contents = [] contents = []
keywords = None keywords = None

hgext/convert/subversion.py

nroot = path.strip('/') nroot = path.strip('/')
children = self._iterfiles(oroot, prevnum) children = self._iterfiles(oroot, prevnum)
for childpath in children: for childpath in children:
childpath = childpath.replace(oroot, nroot) childpath = childpath.replace(oroot, nroot)
childpath = self.getrelpath("/" + childpath, pmodule) childpath = self.getrelpath("/" + childpath, pmodule)
if childpath: if childpath:
removed.add(self.recode(childpath)) removed.add(self.recode(childpath))
else: else:
self.ui.debug('unknown path in revision %d: %s\n' % \ self.ui.debug('unknown path in revision %d: %s\n' %
(revnum, path)) (revnum, path))
elif kind == svn.core.svn_node_dir: elif kind == svn.core.svn_node_dir:
if ent.action == 'M': if ent.action == 'M':
# If the directory just had a prop change, # If the directory just had a prop change,
# then we shouldn't need to look for its children. # then we shouldn't need to look for its children.
continue continue
if ent.action == 'R' and parents: if ent.action == 'R' and parents:
# If a directory is replacing a file, mark the previous # If a directory is replacing a file, mark the previous

hgext/histedit.py

tr = repo.transaction('histedit') tr = repo.transaction('histedit')
progress = ui.makeprogress(_("editing"), unit=_('changes'), progress = ui.makeprogress(_("editing"), unit=_('changes'),
total=len(state.actions)) total=len(state.actions))
with progress, util.acceptintervention(tr): with progress, util.acceptintervention(tr):
while state.actions: while state.actions:
state.write(tr=tr) state.write(tr=tr)
actobj = state.actions[0] actobj = state.actions[0]
progress.increment(item=actobj.torule()) progress.increment(item=actobj.torule())
ui.debug('histedit: processing %s %s\n' % (actobj.verb,\ ui.debug('histedit: processing %s %s\n' % (actobj.verb,
actobj.torule())) actobj.torule()))
parentctx, replacement_ = actobj.run() parentctx, replacement_ = actobj.run()
state.parentctxnode = parentctx.node() state.parentctxnode = parentctx.node()
state.replacements.extend(replacement_) state.replacements.extend(replacement_)
state.actions.pop(0) state.actions.pop(0)
state.write() state.write()
if not rules: if not rules:
comment = geteditcomment(ui, comment = geteditcomment(ui,
node.short(state.parentctxnode), node.short(state.parentctxnode),
node.short(state.topmost)) node.short(state.topmost))
rules = ruleeditor(repo, ui, state.actions, comment) rules = ruleeditor(repo, ui, state.actions, comment)
else: else:
rules = _readfile(ui, rules) rules = _readfile(ui, rules)
actions = parserules(rules, state) actions = parserules(rules, state)
ctxs = [repo[act.node] \ ctxs = [repo[act.node]
for act in state.actions if act.node] for act in state.actions if act.node]
warnverifyactions(ui, repo, actions, state, ctxs) warnverifyactions(ui, repo, actions, state, ctxs)
state.actions = actions state.actions = actions
state.write() state.write()
def _newhistedit(ui, repo, state, revs, freeargs, opts): def _newhistedit(ui, repo, state, revs, freeargs, opts):
outg = opts.get('outgoing') outg = opts.get('outgoing')
rules = opts.get('commands', '') rules = opts.get('commands', '')

hgext/infinitepush/__init__.py

clientextsetup(ui) clientextsetup(ui)
def commonsetup(ui): def commonsetup(ui):
wireprotov1server.commands['listkeyspatterns'] = ( wireprotov1server.commands['listkeyspatterns'] = (
wireprotolistkeyspatterns, 'namespace patterns') wireprotolistkeyspatterns, 'namespace patterns')
scratchbranchpat = ui.config('infinitepush', 'branchpattern') scratchbranchpat = ui.config('infinitepush', 'branchpattern')
if scratchbranchpat: if scratchbranchpat:
global _scratchbranchmatcher global _scratchbranchmatcher
kind, pat, _scratchbranchmatcher = \ kind, pat, _scratchbranchmatcher = (
stringutil.stringmatcher(scratchbranchpat) stringutil.stringmatcher(scratchbranchpat))
def serverextsetup(ui): def serverextsetup(ui):
origpushkeyhandler = bundle2.parthandlermapping['pushkey'] origpushkeyhandler = bundle2.parthandlermapping['pushkey']
def newpushkeyhandler(*args, **kwargs): def newpushkeyhandler(*args, **kwargs):
bundle2pushkey(origpushkeyhandler, *args, **kwargs) bundle2pushkey(origpushkeyhandler, *args, **kwargs)
newpushkeyhandler.params = origpushkeyhandler.params newpushkeyhandler.params = origpushkeyhandler.params
bundle2.parthandlermapping['pushkey'] = newpushkeyhandler bundle2.parthandlermapping['pushkey'] = newpushkeyhandler
orighandlephasehandler = bundle2.parthandlermapping['phase-heads'] orighandlephasehandler = bundle2.parthandlermapping['phase-heads']
newphaseheadshandler = lambda *args, **kwargs: \ newphaseheadshandler = lambda *args, **kwargs: bundle2handlephases(
bundle2handlephases(orighandlephasehandler, *args, **kwargs) orighandlephasehandler, *args, **kwargs)
newphaseheadshandler.params = orighandlephasehandler.params newphaseheadshandler.params = orighandlephasehandler.params
bundle2.parthandlermapping['phase-heads'] = newphaseheadshandler bundle2.parthandlermapping['phase-heads'] = newphaseheadshandler
extensions.wrapfunction(localrepo.localrepository, 'listkeys', extensions.wrapfunction(localrepo.localrepository, 'listkeys',
localrepolistkeys) localrepolistkeys)
wireprotov1server.commands['lookup'] = ( wireprotov1server.commands['lookup'] = (
_lookupwrap(wireprotov1server.commands['lookup'][0]), 'key') _lookupwrap(wireprotov1server.commands['lookup'][0]), 'key')
extensions.wrapfunction(exchange, 'getbundlechunks', getbundlechunks) extensions.wrapfunction(exchange, 'getbundlechunks', getbundlechunks)
""" """
remotenamesext = extensions.find('remotenames') remotenamesext = extensions.find('remotenames')
# remotename format is: # remotename format is:
# (node, nametype ("branches" or "bookmarks"), remote, name) # (node, nametype ("branches" or "bookmarks"), remote, name)
nametype_idx = 1 nametype_idx = 1
remote_idx = 2 remote_idx = 2
name_idx = 3 name_idx = 3
remotenames = [remotename for remotename in \ remotenames = [remotename for remotename in
remotenamesext.readremotenames(repo) \ remotenamesext.readremotenames(repo)
if remotename[remote_idx] == path] if remotename[remote_idx] == path]
remote_bm_names = [remotename[name_idx] for remotename in \ remote_bm_names = [remotename[name_idx] for remotename in
remotenames if remotename[nametype_idx] == "bookmarks"] remotenames if remotename[nametype_idx] == "bookmarks"]
for name in names: for name in names:
if name not in remote_bm_names: if name not in remote_bm_names:
raise error.Abort(_("infinitepush bookmark '{}' does not exist " raise error.Abort(_("infinitepush bookmark '{}' does not exist "
"in path '{}'").format(name, path)) "in path '{}'").format(name, path))
bookmarks = {} bookmarks = {}

hgext/largefiles/lfutil.py

return os.path.join(_usercachedir(ui), hash) return os.path.join(_usercachedir(ui), hash)
def _usercachedir(ui, name=longname): def _usercachedir(ui, name=longname):
'''Return the location of the "global" largefiles cache.''' '''Return the location of the "global" largefiles cache.'''
path = ui.configpath(name, 'usercache') path = ui.configpath(name, 'usercache')
if path: if path:
return path return path
if pycompat.iswindows: if pycompat.iswindows:
appdata = encoding.environ.get('LOCALAPPDATA',\ appdata = encoding.environ.get('LOCALAPPDATA',
encoding.environ.get('APPDATA')) encoding.environ.get('APPDATA'))
if appdata: if appdata:
return os.path.join(appdata, name) return os.path.join(appdata, name)
elif pycompat.isdarwin: elif pycompat.isdarwin:
home = encoding.environ.get('HOME') home = encoding.environ.get('HOME')
if home: if home:
return os.path.join(home, 'Library', 'Caches', name) return os.path.join(home, 'Library', 'Caches', name)
elif pycompat.isposix: elif pycompat.isposix:
path = encoding.environ.get('XDG_CACHE_HOME') path = encoding.environ.get('XDG_CACHE_HOME')

hgext/largefiles/reposetup.py

(modified, added, removed, deleted, clean) = ( (modified, added, removed, deleted, clean) = (
s.modified, s.added, s.removed, s.deleted, s.clean) s.modified, s.added, s.removed, s.deleted, s.clean)
if parentworking: if parentworking:
for lfile in unsure: for lfile in unsure:
standin = lfutil.standin(lfile) standin = lfutil.standin(lfile)
if standin not in ctx1: if standin not in ctx1:
# from second parent # from second parent
modified.append(lfile) modified.append(lfile)
elif lfutil.readasstandin(ctx1[standin]) \ elif (lfutil.readasstandin(ctx1[standin])
!= lfutil.hashfile(self.wjoin(lfile)): != lfutil.hashfile(self.wjoin(lfile))):
modified.append(lfile) modified.append(lfile)
else: else:
if listclean: if listclean:
clean.append(lfile) clean.append(lfile)
lfdirstate.normal(lfile) lfdirstate.normal(lfile)
else: else:
tocheck = unsure + modified + added + clean tocheck = unsure + modified + added + clean
modified, added, clean = [], [], [] modified, added, clean = [], [], []

hgext/record.py

def uisetup(ui): def uisetup(ui):
try: try:
mq = extensions.find('mq') mq = extensions.find('mq')
except KeyError: except KeyError:
return return
cmdtable["qrecord"] = \ cmdtable["qrecord"] = (
(qrecord, qrecord,
# same options as qnew, but copy them so we don't get # same options as qnew, but copy them so we don't get
# -i/--interactive for qrecord and add white space diff options # -i/--interactive for qrecord and add white space diff options
mq.cmdtable['qnew'][1][:] + cmdutil.diffwsopts, mq.cmdtable['qnew'][1][:] + cmdutil.diffwsopts,
_('hg qrecord [OPTION]... PATCH [FILE]...')) _('hg qrecord [OPTION]... PATCH [FILE]...'))
_wrapcmd('qnew', mq.cmdtable, qnew, _("interactively record a new patch")) _wrapcmd('qnew', mq.cmdtable, qnew, _("interactively record a new patch"))
_wrapcmd('qrefresh', mq.cmdtable, qrefresh, _wrapcmd('qrefresh', mq.cmdtable, qrefresh,
_("interactively select changes to refresh")) _("interactively select changes to refresh"))
def _wrapcmd(cmd, table, wrapfn, msg): def _wrapcmd(cmd, table, wrapfn, msg):
entry = extensions.wrapcommand(table, cmd, wrapfn) entry = extensions.wrapcommand(table, cmd, wrapfn)
entry[1].append(('i', 'interactive', None, msg)) entry[1].append(('i', 'interactive', None, msg))

hgext/releasenotes.py

This is used to combine multiple sources of release notes together. This is used to combine multiple sources of release notes together.
""" """
if not fuzz: if not fuzz:
ui.warn(_("module 'fuzzywuzzy' not found, merging of similar " ui.warn(_("module 'fuzzywuzzy' not found, merging of similar "
"releasenotes is disabled\n")) "releasenotes is disabled\n"))
for section in other: for section in other:
existingnotes = converttitled(self.titledforsection(section)) + \ existingnotes = (
convertnontitled(self.nontitledforsection(section)) converttitled(self.titledforsection(section)) +
convertnontitled(self.nontitledforsection(section)))
for title, paragraphs in other.titledforsection(section): for title, paragraphs in other.titledforsection(section):
if self.hastitledinsection(section, title): if self.hastitledinsection(section, title):
# TODO prompt for resolution if different and running in # TODO prompt for resolution if different and running in
# interactive mode. # interactive mode.
ui.write(_('%s already exists in %s section; ignoring\n') % ui.write(_('%s already exists in %s section; ignoring\n') %
(title, section)) (title, section))
continue continue

hgext/remotefilelog/fileserverclient.py

def __init__(self): def __init__(self):
self.pipeo = self.pipei = self.pipee = None self.pipeo = self.pipei = self.pipee = None
self.subprocess = None self.subprocess = None
self.connected = False self.connected = False
def connect(self, cachecommand): def connect(self, cachecommand):
if self.pipeo: if self.pipeo:
raise error.Abort(_("cache connection already open")) raise error.Abort(_("cache connection already open"))
self.pipei, self.pipeo, self.pipee, self.subprocess = \ self.pipei, self.pipeo, self.pipee, self.subprocess = (
procutil.popen4(cachecommand) procutil.popen4(cachecommand))
self.connected = True self.connected = True
def close(self): def close(self):
def tryclose(pipe): def tryclose(pipe):
try: try:
pipe.close() pipe.close()
except Exception: except Exception:
pass pass

hgext/shelve.py

return d return d
@classmethod @classmethod
def load(cls, repo): def load(cls, repo):
version = cls._getversion(repo) version = cls._getversion(repo)
if version < cls._version: if version < cls._version:
d = cls._readold(repo) d = cls._readold(repo)
elif version == cls._version: elif version == cls._version:
d = scmutil.simplekeyvaluefile(repo.vfs, cls._filename)\ d = scmutil.simplekeyvaluefile(
.read(firstlinenonkeyval=True) repo.vfs, cls._filename).read(firstlinenonkeyval=True)
else: else:
raise error.Abort(_('this version of shelve is incompatible ' raise error.Abort(_('this version of shelve is incompatible '
'with the version used in this repo')) 'with the version used in this repo'))
cls._verifyandtransform(d) cls._verifyandtransform(d)
try: try:
obj = cls() obj = cls()
obj.name = d['name'] obj.name = d['name']
"parents": ' '.join([nodemod.hex(p) "parents": ' '.join([nodemod.hex(p)
for p in repo.dirstate.parents()]), for p in repo.dirstate.parents()]),
"nodestoremove": ' '.join([nodemod.hex(n) "nodestoremove": ' '.join([nodemod.hex(n)
for n in nodestoremove]), for n in nodestoremove]),
"branchtorestore": branchtorestore, "branchtorestore": branchtorestore,
"keep": cls._keep if keep else cls._nokeep, "keep": cls._keep if keep else cls._nokeep,
"activebook": activebook or cls._noactivebook "activebook": activebook or cls._noactivebook
} }
scmutil.simplekeyvaluefile(repo.vfs, cls._filename)\ scmutil.simplekeyvaluefile(
.write(info, firstline=("%d" % cls._version)) repo.vfs, cls._filename).write(info,
firstline=("%d" % cls._version))
@classmethod @classmethod
def clear(cls, repo): def clear(cls, repo):
repo.vfs.unlinkpath(cls._filename, ignoremissing=True) repo.vfs.unlinkpath(cls._filename, ignoremissing=True)
def cleanupoldbackups(repo): def cleanupoldbackups(repo):
vfs = vfsmod.vfs(repo.vfs.join(backupdir)) vfs = vfsmod.vfs(repo.vfs.join(backupdir))
maxbackups = repo.ui.configint('shelve', 'maxbackups') maxbackups = repo.ui.configint('shelve', 'maxbackups')

i18n/posplit

directive = mdirective.group(1) directive = mdirective.group(1)
if directive in ('container', 'include'): if directive in ('container', 'include'):
if msgid.rstrip('\n').count('\n') == 0: if msgid.rstrip('\n').count('\n') == 0:
# only rst syntax, nothing to translate # only rst syntax, nothing to translate
delta += 2 delta += 2
continue continue
else: else:
# lines following directly, unexpected # lines following directly, unexpected
print('Warning: text follows line with directive' \ print('Warning: text follows line with directive'
' %s' % directive) ' %s' % directive)
comment = 'do not translate: .. %s::' % directive comment = 'do not translate: .. %s::' % directive
if not newentry.comment: if not newentry.comment:
newentry.comment = comment newentry.comment = comment
elif comment not in newentry.comment: elif comment not in newentry.comment:
newentry.comment += '\n' + comment newentry.comment += '\n' + comment
addentry(po, newentry, cache) addentry(po, newentry, cache)
delta += 2 + msgid.count('\n') delta += 2 + msgid.count('\n')
po.save() po.save()

mercurial/branchmap.py

def validfor(self, repo): def validfor(self, repo):
"""Is the cache content valid regarding a repo """Is the cache content valid regarding a repo
- False when cached tipnode is unknown or if we detect a strip. - False when cached tipnode is unknown or if we detect a strip.
- True when cache is up to date or a subset of current repo.""" - True when cache is up to date or a subset of current repo."""
try: try:
return ((self.tipnode == repo.changelog.node(self.tiprev)) return ((self.tipnode == repo.changelog.node(self.tiprev))
and (self.filteredhash == \ and (self.filteredhash ==
scmutil.filteredhash(repo, self.tiprev))) scmutil.filteredhash(repo, self.tiprev)))
except IndexError: except IndexError:
return False return False
def _branchtip(self, heads): def _branchtip(self, heads):
'''Return tuple with last open head in heads and false, '''Return tuple with last open head in heads and false,
otherwise return last closed head and true.''' otherwise return last closed head and true.'''
tip = heads[-1] tip = heads[-1]

mercurial/bundle2.py

super(seekableunbundlepart, self).__init__(ui, header, fp) super(seekableunbundlepart, self).__init__(ui, header, fp)
def _payloadchunks(self, chunknum=0): def _payloadchunks(self, chunknum=0):
'''seek to specified chunk and start yielding data''' '''seek to specified chunk and start yielding data'''
if len(self._chunkindex) == 0: if len(self._chunkindex) == 0:
assert chunknum == 0, 'Must start with chunk 0' assert chunknum == 0, 'Must start with chunk 0'
self._chunkindex.append((0, self._tellfp())) self._chunkindex.append((0, self._tellfp()))
else: else:
assert chunknum < len(self._chunkindex), \ assert chunknum < len(self._chunkindex), (
'Unknown chunk %d' % chunknum 'Unknown chunk %d' % chunknum)
self._seekfp(self._chunkindex[chunknum][1]) self._seekfp(self._chunkindex[chunknum][1])
pos = self._chunkindex[chunknum][0] pos = self._chunkindex[chunknum][0]
for chunk in decodepayloadchunks(self.ui, self._fp): for chunk in decodepayloadchunks(self.ui, self._fp):
chunknum += 1 chunknum += 1
pos += len(chunk) pos += len(chunk)
if chunknum == len(self._chunkindex): if chunknum == len(self._chunkindex):

mercurial/cmdutil.py

def ishunk(x): def ishunk(x):
hunkclasses = (crecordmod.uihunk, patch.recordhunk) hunkclasses = (crecordmod.uihunk, patch.recordhunk)
return isinstance(x, hunkclasses) return isinstance(x, hunkclasses)
def newandmodified(chunks, originalchunks): def newandmodified(chunks, originalchunks):
newlyaddedandmodifiedfiles = set() newlyaddedandmodifiedfiles = set()
for chunk in chunks: for chunk in chunks:
if ishunk(chunk) and chunk.header.isnewfile() and chunk not in \ if (ishunk(chunk) and chunk.header.isnewfile() and chunk not in
originalchunks: originalchunks):
newlyaddedandmodifiedfiles.add(chunk.header.filename()) newlyaddedandmodifiedfiles.add(chunk.header.filename())
return newlyaddedandmodifiedfiles return newlyaddedandmodifiedfiles
def parsealiases(cmd): def parsealiases(cmd):
return cmd.split("|") return cmd.split("|")
def setupwrapcolorwrite(ui): def setupwrapcolorwrite(ui):
# wrap ui.write so diff output can be labeled/colorized # wrap ui.write so diff output can be labeled/colorized
modified = set(status.modified) modified = set(status.modified)
# 2. backup changed files, so we can restore them in the end # 2. backup changed files, so we can restore them in the end
if backupall: if backupall:
tobackup = changed tobackup = changed
else: else:
tobackup = [f for f in newfiles if f in modified or f in \ tobackup = [f for f in newfiles if f in modified or f in
newlyaddedandmodifiedfiles] newlyaddedandmodifiedfiles]
backups = {} backups = {}
if tobackup: if tobackup:
backupdir = repo.vfs.join('record-backups') backupdir = repo.vfs.join('record-backups')
try: try:
os.mkdir(backupdir) os.mkdir(backupdir)
except OSError as err: except OSError as err:
if err.errno != errno.EEXIST: if err.errno != errno.EEXIST:
raise raise

mercurial/commands.py

extra = {} extra = {}
if opts.get('close_branch'): if opts.get('close_branch'):
extra['close'] = '1' extra['close'] = '1'
if not bheads: if not bheads:
raise error.Abort(_('can only close branch heads')) raise error.Abort(_('can only close branch heads'))
elif opts.get('amend'): elif opts.get('amend'):
if repo['.'].p1().branch() != branch and \ if (repo['.'].p1().branch() != branch and
repo['.'].p2().branch() != branch: repo['.'].p2().branch() != branch):
raise error.Abort(_('can only close branch heads')) raise error.Abort(_('can only close branch heads'))
if opts.get('amend'): if opts.get('amend'):
if ui.configbool('ui', 'commitsubrepos'): if ui.configbool('ui', 'commitsubrepos'):
raise error.Abort(_('cannot amend with ui.commitsubrepos enabled')) raise error.Abort(_('cannot amend with ui.commitsubrepos enabled'))
old = repo['.'] old = repo['.']
rewriteutil.precheck(repo, [old.rev()], 'amend') rewriteutil.precheck(repo, [old.rev()], 'amend')
:path: String. Repository-absolute path of the file. :path: String. Repository-absolute path of the file.
Returns 0 on success, 1 if any files fail a resolve attempt. Returns 0 on success, 1 if any files fail a resolve attempt.
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
confirm = ui.configbool('commands', 'resolve.confirm') confirm = ui.configbool('commands', 'resolve.confirm')
flaglist = 'all mark unmark list no_status re_merge'.split() flaglist = 'all mark unmark list no_status re_merge'.split()
all, mark, unmark, show, nostatus, remerge = \ all, mark, unmark, show, nostatus, remerge = [
[opts.get(o) for o in flaglist] opts.get(o) for o in flaglist]
actioncount = len(list(filter(None, [show, mark, unmark, remerge]))) actioncount = len(list(filter(None, [show, mark, unmark, remerge])))
if actioncount > 1: if actioncount > 1:
raise error.Abort(_("too many actions specified")) raise error.Abort(_("too many actions specified"))
elif (actioncount == 0 elif (actioncount == 0
and ui.configbool('commands', 'resolve.explicit-re-merge')): and ui.configbool('commands', 'resolve.explicit-re-merge')):
hint = _('use --mark, --unmark, --list or --re-merge') hint = _('use --mark, --unmark, --list or --re-merge')
raise error.Abort(_('no action specified'), hint=hint) raise error.Abort(_('no action specified'), hint=hint)
elif ms[f] == mergemod.MERGE_RECORD_UNRESOLVED_PATH: elif ms[f] == mergemod.MERGE_RECORD_UNRESOLVED_PATH:
ui.warn(_('%s: path conflict must be resolved manually\n') ui.warn(_('%s: path conflict must be resolved manually\n')
% uipathfn(f)) % uipathfn(f))
continue continue
if mark: if mark:
if markcheck: if markcheck:
fdata = repo.wvfs.tryread(f) fdata = repo.wvfs.tryread(f)
if filemerge.hasconflictmarkers(fdata) and \ if (filemerge.hasconflictmarkers(fdata) and
ms[f] != mergemod.MERGE_RECORD_RESOLVED: ms[f] != mergemod.MERGE_RECORD_RESOLVED):
hasconflictmarkers.append(f) hasconflictmarkers.append(f)
ms.mark(f, mergemod.MERGE_RECORD_RESOLVED) ms.mark(f, mergemod.MERGE_RECORD_RESOLVED)
elif unmark: elif unmark:
ms.mark(f, mergemod.MERGE_RECORD_UNRESOLVED) ms.mark(f, mergemod.MERGE_RECORD_UNRESOLVED)
else: else:
# backup pre-resolve (merge uses .orig for its own purposes) # backup pre-resolve (merge uses .orig for its own purposes)
a = repo.wjoin(f) a = repo.wjoin(f)
try: try:

mercurial/context.py

filelog=None, changectx=None): filelog=None, changectx=None):
"""changeid must be a revision number, if specified. """changeid must be a revision number, if specified.
fileid can be a file revision or node.""" fileid can be a file revision or node."""
self._repo = repo self._repo = repo
self._path = path self._path = path
assert (changeid is not None assert (changeid is not None
or fileid is not None or fileid is not None
or changectx is not None), \ or changectx is not None), (
("bad args: changeid=%r, fileid=%r, changectx=%r" "bad args: changeid=%r, fileid=%r, changectx=%r"
% (changeid, fileid, changectx)) % (changeid, fileid, changectx))
if filelog is not None: if filelog is not None:
self._filelog = filelog self._filelog = filelog
if changeid is not None: if changeid is not None:
self._changeid = changeid self._changeid = changeid
if changectx is not None: if changectx is not None:
self._changectx = changectx self._changectx = changectx

mercurial/debugcommands.py

age = now - st[stat.ST_MTIME] age = now - st[stat.ST_MTIME]
user = util.username(st.st_uid) user = util.username(st.st_uid)
locker = vfs.readlock(name) locker = vfs.readlock(name)
if ":" in locker: if ":" in locker:
host, pid = locker.split(':') host, pid = locker.split(':')
if host == socket.gethostname(): if host == socket.gethostname():
locker = 'user %s, process %s' % (user or b'None', pid) locker = 'user %s, process %s' % (user or b'None', pid)
else: else:
locker = 'user %s, process %s, host %s' \ locker = ('user %s, process %s, host %s'
% (user or b'None', pid, host) % (user or b'None', pid, host))
ui.write(("%-6s %s (%ds)\n") % (name + ":", locker, age)) ui.write(("%-6s %s (%ds)\n") % (name + ":", locker, age))
return 1 return 1
except OSError as e: except OSError as e:
if e.errno != errno.ENOENT: if e.errno != errno.ENOENT:
raise raise
ui.write(("%-6s free\n") % (name + ":")) ui.write(("%-6s free\n") % (name + ":"))
return 0 return 0

mercurial/exchange.py

return m return m
def isstreamclonespec(bundlespec): def isstreamclonespec(bundlespec):
# Stream clone v1 # Stream clone v1
if (bundlespec.wirecompression == 'UN' and bundlespec.wireversion == 's1'): if (bundlespec.wirecompression == 'UN' and bundlespec.wireversion == 's1'):
return True return True
# Stream clone v2 # Stream clone v2
if (bundlespec.wirecompression == 'UN' and \ if (bundlespec.wirecompression == 'UN' and
bundlespec.wireversion == '02' and \ bundlespec.wireversion == '02' and
bundlespec.contentopts.get('streamv2')): bundlespec.contentopts.get('streamv2')):
return True return True
return False return False
def filterclonebundleentries(repo, entries, streamclonerequested=False): def filterclonebundleentries(repo, entries, streamclonerequested=False):
"""Remove incompatible clone bundle manifest entries. """Remove incompatible clone bundle manifest entries.

mercurial/httpconnection.py

prefixurl.user = None prefixurl.user = None
prefix = bytes(prefixurl) prefix = bytes(prefixurl)
p = prefix.split('://', 1) p = prefix.split('://', 1)
if len(p) > 1: if len(p) > 1:
schemes, prefix = [p[0]], p[1] schemes, prefix = [p[0]], p[1]
else: else:
schemes = (auth.get('schemes') or 'https').split() schemes = (auth.get('schemes') or 'https').split()
if (prefix == '*' or hostpath.startswith(prefix)) and \ if ((prefix == '*' or hostpath.startswith(prefix)) and
(len(prefix) > bestlen or (len(prefix) == bestlen and \ (len(prefix) > bestlen or (len(prefix) == bestlen and
not bestuser and 'username' in auth)) \ not bestuser and 'username' in auth))
and scheme in schemes: and scheme in schemes):
bestlen = len(prefix) bestlen = len(prefix)
bestauth = group, auth bestauth = group, auth
bestuser = auth.get('username') bestuser = auth.get('username')
if user and not bestuser: if user and not bestuser:
auth['username'] = user auth['username'] = user
return bestauth return bestauth

mercurial/merge.py

def active(self): def active(self):
"""Whether mergestate is active. """Whether mergestate is active.
Returns True if there appears to be mergestate. This is a rough proxy Returns True if there appears to be mergestate. This is a rough proxy
for "is a merge in progress." for "is a merge in progress."
""" """
# Check local variables before looking at filesystem for performance # Check local variables before looking at filesystem for performance
# reasons. # reasons.
return bool(self._local) or bool(self._state) or \ return (bool(self._local) or bool(self._state) or
self._repo.vfs.exists(self.statepathv1) or \ self._repo.vfs.exists(self.statepathv1) or
self._repo.vfs.exists(self.statepathv2) self._repo.vfs.exists(self.statepathv2))
def commit(self): def commit(self):
"""Write current state on disk (if necessary)""" """Write current state on disk (if necessary)"""
if self._dirty: if self._dirty:
records = self._makerecords() records = self._makerecords()
self._writerecords(records) self._writerecords(records)
self._dirty = False self._dirty = False

mercurial/minirst.py

if blocks[i]['lines'] == ['::']: if blocks[i]['lines'] == ['::']:
# Expanded form: remove block # Expanded form: remove block
del blocks[i] del blocks[i]
i -= 1 i -= 1
elif blocks[i]['lines'][-1].endswith(' ::'): elif blocks[i]['lines'][-1].endswith(' ::'):
# Partially minimized form: remove space and both # Partially minimized form: remove space and both
# colons. # colons.
blocks[i]['lines'][-1] = blocks[i]['lines'][-1][:-3] blocks[i]['lines'][-1] = blocks[i]['lines'][-1][:-3]
elif len(blocks[i]['lines']) == 1 and \ elif (len(blocks[i]['lines']) == 1 and
blocks[i]['lines'][0].lstrip(' ').startswith('.. ') and \ blocks[i]['lines'][0].lstrip(' ').startswith('.. ') and
blocks[i]['lines'][0].find(' ', 3) == -1: blocks[i]['lines'][0].find(' ', 3) == -1):
# directive on its own line, not a literal block # directive on its own line, not a literal block
i += 1 i += 1
continue continue
else: else:
# Fully minimized form: remove just one colon. # Fully minimized form: remove just one colon.
blocks[i]['lines'][-1] = blocks[i]['lines'][-1][:-1] blocks[i]['lines'][-1] = blocks[i]['lines'][-1][:-1]
# List items are formatted with a hanging indent. We must # List items are formatted with a hanging indent. We must
if b['type'] != 'margin': if b['type'] != 'margin':
pointer = 1 pointer = 1
bindent = b['indent'] bindent = b['indent']
while pointer < len(secs): while pointer < len(secs):
section = secs[-pointer][2][0] section = secs[-pointer][2][0]
if section['type'] != 'margin': if section['type'] != 'margin':
sindent = section['indent'] sindent = section['indent']
if len(section['lines']) > 1: if len(section['lines']) > 1:
sindent += len(section['lines'][1]) - \ sindent += (len(section['lines'][1]) -
len(section['lines'][1].lstrip(' ')) len(section['lines'][1].lstrip(' ')))
if bindent >= sindent: if bindent >= sindent:
break break
pointer += 1 pointer += 1
if pointer > 1: if pointer > 1:
blevel = secs[-pointer][1] blevel = secs[-pointer][1]
if section['type'] != b['type']: if section['type'] != b['type']:
blevel += 1 blevel += 1
secs.append(('', blevel, [])) secs.append(('', blevel, []))

mercurial/patch.py

# level for example a file that has been deleted is a special file. # level for example a file that has been deleted is a special file.
# The user cannot change the content of the operation, in the case of # The user cannot change the content of the operation, in the case of
# the deleted file he has to take the deletion or not take it, he # the deleted file he has to take the deletion or not take it, he
# cannot take some of it. # cannot take some of it.
# Newly added files are special if they are empty, they are not special # Newly added files are special if they are empty, they are not special
# if they have some content as we want to be able to change it # if they have some content as we want to be able to change it
nocontent = len(self.header) == 2 nocontent = len(self.header) == 2
emptynewfile = self.isnewfile() and nocontent emptynewfile = self.isnewfile() and nocontent
return emptynewfile or \ return (emptynewfile
any(self.special_re.match(h) for h in self.header) or any(self.special_re.match(h) for h in self.header))
class recordhunk(object): class recordhunk(object):
"""patch hunk """patch hunk
XXX shouldn't we merge this with the other hunk class? XXX shouldn't we merge this with the other hunk class?
""" """
def __init__(self, header, fromline, toline, proc, before, hunk, after, def __init__(self, header, fromline, toline, proc, before, hunk, after,
for fctx1, fctx2, hdr, hunks in diffhunks( for fctx1, fctx2, hdr, hunks in diffhunks(
repo, ctx1=ctx1, ctx2=ctx2, match=match, changes=changes, opts=opts, repo, ctx1=ctx1, ctx2=ctx2, match=match, changes=changes, opts=opts,
losedatafn=losedatafn, pathfn=pathfn, copy=copy, losedatafn=losedatafn, pathfn=pathfn, copy=copy,
copysourcematch=copysourcematch): copysourcematch=copysourcematch):
if hunksfilterfn is not None: if hunksfilterfn is not None:
# If the file has been removed, fctx2 is None; but this should # If the file has been removed, fctx2 is None; but this should
# not occur here since we catch removed files early in # not occur here since we catch removed files early in
# logcmdutil.getlinerangerevs() for 'hg log -L'. # logcmdutil.getlinerangerevs() for 'hg log -L'.
assert fctx2 is not None, \ assert fctx2 is not None, (
'fctx2 unexpectly None in diff hunks filtering' 'fctx2 unexpectly None in diff hunks filtering')
hunks = hunksfilterfn(fctx2, hunks) hunks = hunksfilterfn(fctx2, hunks)
text = ''.join(sum((list(hlines) for hrange, hlines in hunks), [])) text = ''.join(sum((list(hlines) for hrange, hlines in hunks), []))
if hdr and (text or len(hdr) > 1): if hdr and (text or len(hdr) > 1):
yield '\n'.join(hdr) + '\n' yield '\n'.join(hdr) + '\n'
if text: if text:
yield text yield text
def diffhunks(repo, ctx1, ctx2, match=None, changes=None, opts=None, def diffhunks(repo, ctx1, ctx2, match=None, changes=None, opts=None,

mercurial/simplemerge.py

yield region yield region
continue continue
issue, z1, z2, a1, a2, b1, b2 = region issue, z1, z2, a1, a2, b1, b2 = region
alen = a2 - a1 alen = a2 - a1
blen = b2 - b1 blen = b2 - b1
# find matches at the front # find matches at the front
ii = 0 ii = 0
while ii < alen and ii < blen and \ while (ii < alen and ii < blen and
self.a[a1 + ii] == self.b[b1 + ii]: self.a[a1 + ii] == self.b[b1 + ii]):
ii += 1 ii += 1
startmatches = ii startmatches = ii
# find matches at the end # find matches at the end
ii = 0 ii = 0
while ii < alen and ii < blen and \ while (ii < alen and ii < blen and
self.a[a2 - ii - 1] == self.b[b2 - ii - 1]: self.a[a2 - ii - 1] == self.b[b2 - ii - 1]):
ii += 1 ii += 1
endmatches = ii endmatches = ii
if startmatches > 0: if startmatches > 0:
yield 'same', a1, a1 + startmatches yield 'same', a1, a1 + startmatches
yield ('conflict', z1, z2, yield ('conflict', z1, z2,
a1 + startmatches, a2 - endmatches, a1 + startmatches, a2 - endmatches,
assert abase <= intbase assert abase <= intbase
assert bbase <= intbase assert bbase <= intbase
asub = amatch + (intbase - abase) asub = amatch + (intbase - abase)
bsub = bmatch + (intbase - bbase) bsub = bmatch + (intbase - bbase)
aend = asub + intlen aend = asub + intlen
bend = bsub + intlen bend = bsub + intlen
assert self.base[intbase:intend] == self.a[asub:aend], \ assert self.base[intbase:intend] == self.a[asub:aend], (
(self.base[intbase:intend], self.a[asub:aend]) (self.base[intbase:intend], self.a[asub:aend]))
assert self.base[intbase:intend] == self.b[bsub:bend] assert self.base[intbase:intend] == self.b[bsub:bend]
sl.append((intbase, intend, sl.append((intbase, intend,
asub, aend, asub, aend,
bsub, bend)) bsub, bend))
# advance whichever one ends first in the base text # advance whichever one ends first in the base text

mercurial/sparse.py

if not usereporootpaths: if not usereporootpaths:
# let's treat paths as relative to cwd # let's treat paths as relative to cwd
root, cwd = repo.root, repo.getcwd() root, cwd = repo.root, repo.getcwd()
abspats = [] abspats = []
for kindpat in pats: for kindpat in pats:
kind, pat = matchmod._patsplit(kindpat, None) kind, pat = matchmod._patsplit(kindpat, None)
if kind in matchmod.cwdrelativepatternkinds or kind is None: if kind in matchmod.cwdrelativepatternkinds or kind is None:
ap = (kind + ':' if kind else '') +\ ap = ((kind + ':' if kind else '') +
pathutil.canonpath(root, cwd, pat) pathutil.canonpath(root, cwd, pat))
abspats.append(ap) abspats.append(ap)
else: else:
abspats.append(kindpat) abspats.append(kindpat)
pats = abspats pats = abspats
if include: if include:
newinclude.update(pats) newinclude.update(pats)
elif exclude: elif exclude:

mercurial/subrepo.py

possibly by force and/or after the file has been removed from the possibly by force and/or after the file has been removed from the
filesystem. Return 0 on success, 1 on any warning. filesystem. Return 0 on success, 1 on any warning.
""" """
warnings.append(_("warning: removefiles not implemented (%s)") warnings.append(_("warning: removefiles not implemented (%s)")
% self._path) % self._path)
return 1 return 1
def revert(self, substate, *pats, **opts): def revert(self, substate, *pats, **opts):
self.ui.warn(_('%s: reverting %s subrepos is unsupported\n') \ self.ui.warn(_('%s: reverting %s subrepos is unsupported\n')
% (substate[0], substate[2])) % (substate[0], substate[2]))
return [] return []
def shortid(self, revid): def shortid(self, revid):
return revid return revid
def unshare(self): def unshare(self):
''' '''
convert this repository from shared to normal storage. convert this repository from shared to normal storage.
source, revision, kind = state source, revision, kind = state
repo = self._repo repo = self._repo
repo.ui.debug("getting subrepo %s\n" % self._path) repo.ui.debug("getting subrepo %s\n" % self._path)
if inrepo: if inrepo:
urepo = repo.unfiltered() urepo = repo.unfiltered()
ctx = urepo[revision] ctx = urepo[revision]
if ctx.hidden(): if ctx.hidden():
urepo.ui.warn( urepo.ui.warn(
_('revision %s in subrepository "%s" is hidden\n') \ _('revision %s in subrepository "%s" is hidden\n')
% (revision[0:12], self._path)) % (revision[0:12], self._path))
repo = urepo repo = urepo
hg.updaterepo(repo, revision, overwrite) hg.updaterepo(repo, revision, overwrite)
@annotatesubrepoerror @annotatesubrepoerror
def merge(self, state): def merge(self, state):
self._get(state) self._get(state)
cur = self._repo['.'] cur = self._repo['.']
else: else:
cmd.extend(['--src-prefix=a/%s/' % prefix, cmd.extend(['--src-prefix=a/%s/' % prefix,
'--dst-prefix=b/%s/' % prefix]) '--dst-prefix=b/%s/' % prefix])
if diffopts.ignorews: if diffopts.ignorews:
cmd.append('--ignore-all-space') cmd.append('--ignore-all-space')
if diffopts.ignorewsamount: if diffopts.ignorewsamount:
cmd.append('--ignore-space-change') cmd.append('--ignore-space-change')
if self._gitversion(self._gitcommand(['--version'])) >= (1, 8, 4) \ if (self._gitversion(self._gitcommand(['--version'])) >= (1, 8, 4)
and diffopts.ignoreblanklines: and diffopts.ignoreblanklines):
cmd.append('--ignore-blank-lines') cmd.append('--ignore-blank-lines')
cmd.append(node1) cmd.append(node1)
if node2: if node2:
cmd.append(node2) cmd.append(node2)
output = "" output = ""
if match.always(): if match.always():

mercurial/tags.py

# XXX is this really 100% correct? are there oddball special # XXX is this really 100% correct? are there oddball special
# cases where a global tag should outrank a local tag but won't, # cases where a global tag should outrank a local tag but won't,
# because cachetags does not contain rank info? # because cachetags does not contain rank info?
alltags = {} alltags = {}
_updatetags(cachetags, alltags) _updatetags(cachetags, alltags)
return alltags return alltags
for head in reversed(heads): # oldest to newest for head in reversed(heads): # oldest to newest
assert head in repo.changelog.nodemap, \ assert head in repo.changelog.nodemap, (
"tag cache returned bogus head %s" % short(head) "tag cache returned bogus head %s" % short(head))
fnodes = _filterfnodes(tagfnode, reversed(heads)) fnodes = _filterfnodes(tagfnode, reversed(heads))
alltags = _tagsfromfnodes(ui, repo, fnodes) alltags = _tagsfromfnodes(ui, repo, fnodes)
# and update the cache (if necessary) # and update the cache (if necessary)
if shouldwrite: if shouldwrite:
_writetagcache(ui, repo, valid, alltags) _writetagcache(ui, repo, valid, alltags)
return alltags return alltags

mercurial/ui.py

@contextlib.contextmanager @contextlib.contextmanager
def timeblockedsection(self, key): def timeblockedsection(self, key):
# this is open-coded below - search for timeblockedsection to find them # this is open-coded below - search for timeblockedsection to find them
starttime = util.timer() starttime = util.timer()
try: try:
yield yield
finally: finally:
self._blockedtimes[key + '_blocked'] += \ self._blockedtimes[key + '_blocked'] += (
(util.timer() - starttime) * 1000 (util.timer() - starttime) * 1000)
@contextlib.contextmanager @contextlib.contextmanager
def uninterruptible(self): def uninterruptible(self):
"""Mark an operation as unsafe. """Mark an operation as unsafe.
Most operations on a repository are safe to interrupt, but a Most operations on a repository are safe to interrupt, but a
few are risky (for example repair.strip). This context manager few are risky (for example repair.strip). This context manager
lets you advise Mercurial that something risky is happening so lets you advise Mercurial that something risky is happening so
else: else:
if self._colormode is not None: if self._colormode is not None:
label = opts.get(r'label', '') label = opts.get(r'label', '')
msg = self.label(msg, label) msg = self.label(msg, label)
dest.write(msg) dest.write(msg)
except IOError as err: except IOError as err:
raise error.StdioError(err) raise error.StdioError(err)
finally: finally:
self._blockedtimes['stdio_blocked'] += \ self._blockedtimes['stdio_blocked'] += (
(util.timer() - starttime) * 1000 (util.timer() - starttime) * 1000)
def write_err(self, *args, **opts): def write_err(self, *args, **opts):
self._write(self._ferr, *args, **opts) self._write(self._ferr, *args, **opts)
def _write(self, dest, *args, **opts): def _write(self, dest, *args, **opts):
# update write() as well if you touch this code # update write() as well if you touch this code
if self._isbuffered(dest): if self._isbuffered(dest):
label = opts.get(r'label', '') label = opts.get(r'label', '')
dest.flush() dest.flush()
except IOError as err: except IOError as err:
if (dest is self._ferr if (dest is self._ferr
and err.errno in (errno.EPIPE, errno.EIO, errno.EBADF)): and err.errno in (errno.EPIPE, errno.EIO, errno.EBADF)):
# no way to report the error, so ignore it # no way to report the error, so ignore it
return return
raise error.StdioError(err) raise error.StdioError(err)
finally: finally:
self._blockedtimes['stdio_blocked'] += \ self._blockedtimes['stdio_blocked'] += (
(util.timer() - starttime) * 1000 (util.timer() - starttime) * 1000)
def _writemsg(self, dest, *args, **opts): def _writemsg(self, dest, *args, **opts):
_writemsgwith(self._write, dest, *args, **opts) _writemsgwith(self._write, dest, *args, **opts)
def _writemsgnobuf(self, dest, *args, **opts): def _writemsgnobuf(self, dest, *args, **opts):
_writemsgwith(self._writenobuf, dest, *args, **opts) _writemsgwith(self._writenobuf, dest, *args, **opts)
def flush(self): def flush(self):
# opencode timeblockedsection because this is a critical path # opencode timeblockedsection because this is a critical path
starttime = util.timer() starttime = util.timer()
try: try:
try: try:
self._fout.flush() self._fout.flush()
except IOError as err: except IOError as err:
if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF): if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF):
raise error.StdioError(err) raise error.StdioError(err)
finally: finally:
try: try:
self._ferr.flush() self._ferr.flush()
except IOError as err: except IOError as err:
if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF): if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF):
raise error.StdioError(err) raise error.StdioError(err)
finally: finally:
self._blockedtimes['stdio_blocked'] += \ self._blockedtimes['stdio_blocked'] += (
(util.timer() - starttime) * 1000 (util.timer() - starttime) * 1000)
def _isatty(self, fh): def _isatty(self, fh):
if self.configbool('ui', 'nontty'): if self.configbool('ui', 'nontty'):
return False return False
return procutil.isatty(fh) return procutil.isatty(fh)
def protectfinout(self): def protectfinout(self):
"""Duplicate ui streams and redirect original if they are stdio """Duplicate ui streams and redirect original if they are stdio

setup.py

self.mkpath(join('mercurial', modir)) self.mkpath(join('mercurial', modir))
self.make_file([pofile], mobuildfile, spawn, (cmd,)) self.make_file([pofile], mobuildfile, spawn, (cmd,))
class hgdist(Distribution): class hgdist(Distribution):
pure = False pure = False
cffi = ispypy cffi = ispypy
global_options = Distribution.global_options + \ global_options = Distribution.global_options + [
[('pure', None, "use pure (slow) Python " ('pure', None, "use pure (slow) Python code instead of C extensions"),
"code instead of C extensions"),
] ]
def has_ext_modules(self): def has_ext_modules(self):
# self.ext_modules is emptied in hgbuildpy.finalize_options which is # self.ext_modules is emptied in hgbuildpy.finalize_options which is
# too late for some cases # too late for some cases
return not self.pure and Distribution.has_ext_modules(self) return not self.pure and Distribution.has_ext_modules(self)
# This is ugly as a one-liner. So use a variable. # This is ugly as a one-liner. So use a variable.
buildextnegops = dict(getattr(build_ext, 'negative_options', {})) buildextnegops = dict(getattr(build_ext, 'negative_options', {}))

tests/hghave.py

@checkvers("svn", "subversion client and admin tools >= %s", (1.3, 1.5)) @checkvers("svn", "subversion client and admin tools >= %s", (1.3, 1.5))
def has_svn_range(v): def has_svn_range(v):
major, minor = v.split('.')[0:2] major, minor = v.split('.')[0:2]
return getsvnversion() >= (int(major), int(minor)) return getsvnversion() >= (int(major), int(minor))
@check("svn", "subversion client and admin tools") @check("svn", "subversion client and admin tools")
def has_svn(): def has_svn():
return matchoutput('svn --version 2>&1', br'^svn, version') and \ return (matchoutput('svn --version 2>&1', br'^svn, version') and
matchoutput('svnadmin --version 2>&1', br'^svnadmin, version') matchoutput('svnadmin --version 2>&1', br'^svnadmin, version'))
@check("svn-bindings", "subversion python bindings") @check("svn-bindings", "subversion python bindings")
def has_svn_bindings(): def has_svn_bindings():
try: try:
import svn.core import svn.core
version = svn.core.SVN_VER_MAJOR, svn.core.SVN_VER_MINOR version = svn.core.SVN_VER_MAJOR, svn.core.SVN_VER_MINOR
if version < (1, 4): if version < (1, 4):
return False return False

tests/run-tests.py

self._skipped = True self._skipped = True
raise unittest.SkipTest(missing[-1]) raise unittest.SkipTest(missing[-1])
elif ret == 'timeout': elif ret == 'timeout':
self.fail('timed out') self.fail('timed out')
elif ret is False: elif ret is False:
self.fail('no result code from test') self.fail('no result code from test')
elif out != self._refout: elif out != self._refout:
# Diff generation may rely on written .err file. # Diff generation may rely on written .err file.
if (ret != 0 or out != self._refout) and not self._skipped \ if ((ret != 0 or out != self._refout) and not self._skipped
and not self._debug: and not self._debug):
with open(self.errpath, 'wb') as f: with open(self.errpath, 'wb') as f:
for line in out: for line in out:
f.write(line) f.write(line)
# The result object handles diff calculation for us. # The result object handles diff calculation for us.
with firstlock: with firstlock:
if self._result.addOutputMismatch(self, ret, out, self._refout): if self._result.addOutputMismatch(self, ret, out, self._refout):
# change was accepted, skip failing # change was accepted, skip failing
shutil.rmtree(self._testtmp, True) shutil.rmtree(self._testtmp, True)
shutil.rmtree(self._threadtmp, True) shutil.rmtree(self._threadtmp, True)
if self._usechg: if self._usechg:
# chgservers will stop automatically after they find the socket # chgservers will stop automatically after they find the socket
# files are deleted # files are deleted
shutil.rmtree(self._chgsockdir, True) shutil.rmtree(self._chgsockdir, True)
if (self._ret != 0 or self._out != self._refout) and not self._skipped \ if ((self._ret != 0 or self._out != self._refout) and not self._skipped
and not self._debug and self._out: and not self._debug and self._out):
with open(self.errpath, 'wb') as f: with open(self.errpath, 'wb') as f:
for line in self._out: for line in self._out:
f.write(line) f.write(line)
vlog("# Ret was:", self._ret, '(%s)' % self.name) vlog("# Ret was:", self._ret, '(%s)' % self.name)
def _run(self, env): def _run(self, env):
# This should be implemented in child classes to run tests. # This should be implemented in child classes to run tests.
env["HGENCODING"] = "ascii" env["HGENCODING"] = "ascii"
env["HGENCODINGMODE"] = "strict" env["HGENCODINGMODE"] = "strict"
env["HGHOSTNAME"] = "test-hostname" env["HGHOSTNAME"] = "test-hostname"
env['HGIPV6'] = str(int(self._useipv6)) env['HGIPV6'] = str(int(self._useipv6))
# See contrib/catapipe.py for how to use this functionality. # See contrib/catapipe.py for how to use this functionality.
if 'HGTESTCATAPULTSERVERPIPE' not in env: if 'HGTESTCATAPULTSERVERPIPE' not in env:
# If we don't have HGTESTCATAPULTSERVERPIPE explicitly set, pull the # If we don't have HGTESTCATAPULTSERVERPIPE explicitly set, pull the
# non-test one in as a default, otherwise set to devnull # non-test one in as a default, otherwise set to devnull
env['HGTESTCATAPULTSERVERPIPE'] = \ env['HGTESTCATAPULTSERVERPIPE'] = env.get(
env.get('HGCATAPULTSERVERPIPE', os.devnull) 'HGCATAPULTSERVERPIPE', os.devnull)
extraextensions = [] extraextensions = []
for opt in self._extraconfigopts: for opt in self._extraconfigopts:
section, key = opt.encode('utf-8').split(b'.', 1) section, key = opt.encode('utf-8').split(b'.', 1)
if section != 'extensions': if section != 'extensions':
continue continue
name = key.split(b'=', 1)[0] name = key.split(b'=', 1)[0]
extraextensions.append(name) extraextensions.append(name)

tests/test-duplicateoptions.py

for option in commands.globalopts: for option in commands.globalopts:
option[0] and globalshort.add(option[0]) option[0] and globalshort.add(option[0])
option[1] and globallong.add(option[1]) option[1] and globallong.add(option[1])
for cmd, entry in commands.table.items(): for cmd, entry in commands.table.items():
seenshort = globalshort.copy() seenshort = globalshort.copy()
seenlong = globallong.copy() seenlong = globallong.copy()
for option in entry[1]: for option in entry[1]:
if (option[0] and option[0] in seenshort) or \ if ((option[0] and option[0] in seenshort) or
(option[1] and option[1] in seenlong): (option[1] and option[1] in seenlong)):
print("command '" + cmd + "' has duplicate option " + str(option)) print("command '" + cmd + "' has duplicate option " + str(option))
seenshort.add(option[0]) seenshort.add(option[0])
seenlong.add(option[1]) seenlong.add(option[1])

tests/test-run-tests.py

... except AssertionError as ex: print(ex) ... except AssertionError as ex: print(ex)
missing newline missing newline
>>> try: lm(b'single backslash\n', b'single \backslash\n') >>> try: lm(b'single backslash\n', b'single \backslash\n')
... except AssertionError as ex: prn(ex) ... except AssertionError as ex: prn(ex)
single backslash or unknown char single backslash or unknown char
""" """
assert (expected.endswith(b'\n') assert (expected.endswith(b'\n')
and output.endswith(b'\n')), 'missing newline' and output.endswith(b'\n')), 'missing newline'
assert not re.search(br'[^ \w\\/\r\n()*?]', expected + output), \ assert not re.search(br'[^ \w\\/\r\n()*?]', expected + output), (
b'single backslash or unknown char' b'single backslash or unknown char')
test = run_tests.TTest(b'test-run-test.t', b'.', b'.') test = run_tests.TTest(b'test-run-test.t', b'.', b'.')
match, exact = test.linematch(expected, output) match, exact = test.linematch(expected, output)
if isinstance(match, str): if isinstance(match, str):
return 'special: ' + match return 'special: ' + match
elif isinstance(match, bytes): elif isinstance(match, bytes):
return 'special: ' + match.decode('utf-8') return 'special: ' + match.decode('utf-8')
else: else:
return bool(match) # do not return match object return bool(match) # do not return match object

tests/test-simplekeyvaluefile.py

with self.assertRaisesRegex(error.CorruptedState, with self.assertRaisesRegex(error.CorruptedState,
'dictionary.*element.*'): 'dictionary.*element.*'):
scmutil.simplekeyvaluefile(self.vfs, b'badfile').read() scmutil.simplekeyvaluefile(self.vfs, b'badfile').read()
def testfirstline(self): def testfirstline(self):
dw = {b'key1': b'value1'} dw = {b'key1': b'value1'}
scmutil.simplekeyvaluefile(self.vfs, b'fl').write(dw, firstline=b'1.0') scmutil.simplekeyvaluefile(self.vfs, b'fl').write(dw, firstline=b'1.0')
self.assertEqual(self.vfs.read(b'fl'), b'1.0\nkey1=value1\n') self.assertEqual(self.vfs.read(b'fl'), b'1.0\nkey1=value1\n')
dr = scmutil.simplekeyvaluefile(self.vfs, b'fl')\ dr = scmutil.simplekeyvaluefile(
.read(firstlinenonkeyval=True) self.vfs, b'fl').read(firstlinenonkeyval=True)
self.assertEqual(dr, {b'__firstline': b'1.0', b'key1': b'value1'}) self.assertEqual(dr, {b'__firstline': b'1.0', b'key1': b'value1'})
if __name__ == "__main__": if __name__ == "__main__":
silenttestrunner.main(__name__) silenttestrunner.main(__name__)