( )⚙ D7539 cleanup: fix docstring formatting

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7539

cleanup: fix docstring formatting
ClosedPublic

Authored by mharbison72 on Dec 1 2019, 7:10 PM.

Details

Reviewers
martinvonz
dlax
pulkit
Group Reviewers
hg-reviewers
Commits
rHGbe8552f25cab: cleanup: fix docstring formatting
rHGc190f2715277: cleanup: fix docstring formatting
Summary

This is just removing the b'' prefix (except demandimportpy2), and making sure
it is triple quoted. I skipped the mapping.py module in zope because that's 3rd
party code.

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

mharbison72 created this revision.Dec 1 2019, 7:10 PM
dlax accepted this revision.Dec 2 2019, 3:29 AM
pulkit accepted this revision.Dec 2 2019, 10:10 AM
This revision is now accepted and ready to land.Dec 2 2019, 10:10 AM
mharbison72 added a commit: rHGc190f2715277: cleanup: fix docstring formatting.Dec 2 2019, 5:00 PM
Closed by commit rHGc190f2715277: cleanup: fix docstring formatting (authored by mharbison72). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 18434

hgdemandimport/demandimportpy2.py

ignores = ignoreset ignores = ignoreset
def isenabled(): def isenabled():
return builtins.__import__ == _demandimport return builtins.__import__ == _demandimport
def enable(): def enable():
"enable global demand-loading of modules" """enable global demand-loading of modules"""
builtins.__import__ = _demandimport builtins.__import__ = _demandimport
def disable(): def disable():
"disable global demand-loading of modules" """disable global demand-loading of modules"""
builtins.__import__ = _origimport builtins.__import__ = _origimport
@contextmanager @contextmanager
def deactivated(): def deactivated():
"context manager for disabling demandimport in 'with' blocks" """context manager for disabling demandimport in 'with' blocks"""
demandenabled = isenabled() demandenabled = isenabled()
if demandenabled: if demandenabled:
disable() disable()
try: try:
yield yield
finally: finally:
if demandenabled: if demandenabled:
enable() enable()

hgext/convert/cvsps.py

def createlog(ui, directory=None, root=b"", rlog=True, cache=None): def createlog(ui, directory=None, root=b"", rlog=True, cache=None):
'''Collect the CVS rlog''' '''Collect the CVS rlog'''
# Because we store many duplicate commit log messages, reusing strings # Because we store many duplicate commit log messages, reusing strings
# saves a lot of memory and pickle storage space. # saves a lot of memory and pickle storage space.
_scache = {} _scache = {}
def scache(s): def scache(s):
b"return a shared version of a string" """return a shared version of a string"""
return _scache.setdefault(s, s) return _scache.setdefault(s, s)
ui.status(_(b'collecting CVS rlog\n')) ui.status(_(b'collecting CVS rlog\n'))
log = [] # list of logentry objects containing the CVS state log = [] # list of logentry objects containing the CVS state
# patterns to match in CVS (r)log output, by state of use # patterns to match in CVS (r)log output, by state of use
re_00 = re.compile(b'RCS file: (.+)$') re_00 = re.compile(b'RCS file: (.+)$')
# "File file4 was added on branch ..." (synthetic, 1 entry) # "File file4 was added on branch ..." (synthetic, 1 entry)
# "Add file3 and file4 to fix ..." (real, 2 entries) # "Add file3 and file4 to fix ..." (real, 2 entries)
# Hence the check for 1 entry here. # Hence the check for 1 entry here.
c.synthetic = len(c.entries) == 1 and c.entries[0].synthetic c.synthetic = len(c.entries) == 1 and c.entries[0].synthetic
# Sort files in each changeset # Sort files in each changeset
def entitycompare(l, r): def entitycompare(l, r):
b'Mimic cvsps sorting order' """Mimic cvsps sorting order"""
l = l.file.split(b'/') l = l.file.split(b'/')
r = r.file.split(b'/') r = r.file.split(b'/')
nl = len(l) nl = len(l)
nr = len(r) nr = len(r)
n = min(nl, nr) n = min(nl, nr)
for i in range(n): for i in range(n):
if i + 1 == nl and nl < nr: if i + 1 == nl and nl < nr:
return -1 return -1

hgext/convert/p4.py

procutil, procutil,
stringutil, stringutil,
) )
from . import common from . import common
def loaditer(f): def loaditer(f):
b"Yield the dictionary objects generated by p4" """Yield the dictionary objects generated by p4"""
try: try:
while True: while True:
d = marshal.load(f) d = marshal.load(f)
if not d: if not d:
break break
yield d yield d
except EOFError: except EOFError:
pass pass
Revisions in the map are considered beeing present in the Revisions in the map are considered beeing present in the
repository and ignored during _parse(). This allows for incremental repository and ignored during _parse(). This allows for incremental
imports if a revmap is provided. imports if a revmap is provided.
""" """
self.revmap = revmap self.revmap = revmap
def _parse_view(self, path): def _parse_view(self, path):
b"Read changes affecting the path" """Read changes affecting the path"""
cmd = b'p4 -G changes -s submitted %s' % procutil.shellquote(path) cmd = b'p4 -G changes -s submitted %s' % procutil.shellquote(path)
stdout = procutil.popen(cmd, mode=b'rb') stdout = procutil.popen(cmd, mode=b'rb')
p4changes = {} p4changes = {}
for d in loaditer(stdout): for d in loaditer(stdout):
c = d.get(b"change", None) c = d.get(b"change", None)
if c: if c:
p4changes[c] = True p4changes[c] = True
return p4changes return p4changes
def _parse(self, ui, path): def _parse(self, ui, path):
b"Prepare list of P4 filenames and revisions to import" """Prepare list of P4 filenames and revisions to import"""
p4changes = {} p4changes = {}
changeset = {} changeset = {}
files_map = {} files_map = {}
copies_map = {} copies_map = {}
localname = {} localname = {}
depotname = {} depotname = {}
heads = [] heads = []

hgext/hgk.py

@command( @command(
b'view', b'view',
[(b'l', b'limit', b'', _(b'limit number of changes displayed'), _(b'NUM'))], [(b'l', b'limit', b'', _(b'limit number of changes displayed'), _(b'NUM'))],
_(b'[-l LIMIT] [REVRANGE]'), _(b'[-l LIMIT] [REVRANGE]'),
helpcategory=command.CATEGORY_CHANGE_NAVIGATION, helpcategory=command.CATEGORY_CHANGE_NAVIGATION,
) )
def view(ui, repo, *etc, **opts): def view(ui, repo, *etc, **opts):
b"start interactive history viewer" """start interactive history viewer"""
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
os.chdir(repo.root) os.chdir(repo.root)
optstr = b' '.join( optstr = b' '.join(
[b'--%s %s' % (k, v) for k, v in pycompat.iteritems(opts) if v] [b'--%s %s' % (k, v) for k, v in pycompat.iteritems(opts) if v]
) )
if repo.filtername is None: if repo.filtername is None:
optstr += b'--hidden' optstr += b'--hidden'
cmd = ui.config(b"hgk", b"path") + b" %s %s" % (optstr, b" ".join(etc)) cmd = ui.config(b"hgk", b"path") + b" %s %s" % (optstr, b" ".join(etc))
ui.debug(b"running %s\n" % cmd) ui.debug(b"running %s\n" % cmd)
ui.system(cmd, blockedtag=b'hgk_view') ui.system(cmd, blockedtag=b'hgk_view')

hgext/rebase.py

text=commitmsg, user=user, date=date, extra=extra, editor=editor text=commitmsg, user=user, date=date, extra=extra, editor=editor
) )
repo.dirstate.setbranch(repo[newnode].branch()) repo.dirstate.setbranch(repo[newnode].branch())
return newnode return newnode
def rebasenode(repo, rev, p1, base, collapse, dest, wctx): def rebasenode(repo, rev, p1, base, collapse, dest, wctx):
b'Rebase a single revision rev on top of p1 using base as merge ancestor' """Rebase a single revision rev on top of p1 using base as merge ancestor"""
# Merge phase # Merge phase
# Update to destination and merge it with local # Update to destination and merge it with local
if wctx.isinmemory(): if wctx.isinmemory():
wctx.setbase(repo[p1]) wctx.setbase(repo[p1])
else: else:
if repo[b'.'].rev() != p1: if repo[b'.'].rev() != p1:
repo.ui.debug(b" update to %d:%s\n" % (p1, repo[p1])) repo.ui.debug(b" update to %d:%s\n" % (p1, repo[p1]))
mergemod.update(repo, p1, branchmerge=False, force=True) mergemod.update(repo, p1, branchmerge=False, force=True)
) )
repo.ui.debug(b" future parents are %d and %d\n" % tuple(newps)) repo.ui.debug(b" future parents are %d and %d\n" % tuple(newps))
return newps[0], newps[1], base return newps[0], newps[1], base
def isagitpatch(repo, patchname): def isagitpatch(repo, patchname):
b'Return true if the given patch is in git format' """Return true if the given patch is in git format"""
mqpatch = os.path.join(repo.mq.path, patchname) mqpatch = os.path.join(repo.mq.path, patchname)
for line in patch.linereader(open(mqpatch, b'rb')): for line in patch.linereader(open(mqpatch, b'rb')):
if line.startswith(b'diff --git'): if line.startswith(b'diff --git'):
return True return True
return False return False
def updatemq(repo, state, skipped, **opts): def updatemq(repo, state, skipped, **opts):
b'Update rebased mq patches - finalize and then import them' """Update rebased mq patches - finalize and then import them"""
mqrebase = {} mqrebase = {}
mq = repo.mq mq = repo.mq
original_series = mq.fullseries[:] original_series = mq.fullseries[:]
skippedpatches = set() skippedpatches = set()
for p in mq.applied: for p in mq.applied:
rev = repo[p.node].rev() rev = repo[p.node].rev()
if rev in state: if rev in state:
if mq.guard_re.split(s, 1)[0] not in skippedpatches if mq.guard_re.split(s, 1)[0] not in skippedpatches
] ]
mq.fullseries[:] = newseries mq.fullseries[:] = newseries
mq.seriesdirty = True mq.seriesdirty = True
mq.savedirty() mq.savedirty()
def storecollapsemsg(repo, collapsemsg): def storecollapsemsg(repo, collapsemsg):
b'Store the collapse message to allow recovery' """Store the collapse message to allow recovery"""
collapsemsg = collapsemsg or b'' collapsemsg = collapsemsg or b''
f = repo.vfs(b"last-message.txt", b"w") f = repo.vfs(b"last-message.txt", b"w")
f.write(b"%s\n" % collapsemsg) f.write(b"%s\n" % collapsemsg)
f.close() f.close()
def clearcollapsemsg(repo): def clearcollapsemsg(repo):
b'Remove collapse message file' """Remove collapse message file"""
repo.vfs.unlinkpath(b"last-message.txt", ignoremissing=True) repo.vfs.unlinkpath(b"last-message.txt", ignoremissing=True)
def restorecollapsemsg(repo, isabort): def restorecollapsemsg(repo, isabort):
b'Restore previously stored collapse message' """Restore previously stored collapse message"""
try: try:
f = repo.vfs(b"last-message.txt") f = repo.vfs(b"last-message.txt")
collapsemsg = f.readline().strip() collapsemsg = f.readline().strip()
f.close() f.close()
except IOError as err: except IOError as err:
if err.errno != errno.ENOENT: if err.errno != errno.ENOENT:
raise raise
if isabort: if isabort:
# Oh well, just abort like normal # Oh well, just abort like normal
collapsemsg = b'' collapsemsg = b''
else: else:
raise error.Abort(_(b'missing .hg/last-message.txt for rebase')) raise error.Abort(_(b'missing .hg/last-message.txt for rebase'))
return collapsemsg return collapsemsg
def clearstatus(repo): def clearstatus(repo):
b'Remove the status files' """Remove the status files"""
# Make sure the active transaction won't write the state file # Make sure the active transaction won't write the state file
tr = repo.currenttransaction() tr = repo.currenttransaction()
if tr: if tr:
tr.removefilegenerator(b'rebasestate') tr.removefilegenerator(b'rebasestate')
repo.vfs.unlinkpath(b"rebasestate", ignoremissing=True) repo.vfs.unlinkpath(b"rebasestate", ignoremissing=True)
def needupdate(repo, state): def needupdate(repo, state):
nodechanges = fd(changes, key=b"oldnode", value=b"newnodes") nodechanges = fd(changes, key=b"oldnode", value=b"newnodes")
fm.data(nodechanges=nodechanges) fm.data(nodechanges=nodechanges)
if keepf: if keepf:
replacements = {} replacements = {}
scmutil.cleanupnodes(repo, replacements, b'rebase', moves, backup=backup) scmutil.cleanupnodes(repo, replacements, b'rebase', moves, backup=backup)
def pullrebase(orig, ui, repo, *args, **opts): def pullrebase(orig, ui, repo, *args, **opts):
b'Call rebase after pull if the latter has been invoked with --rebase' """Call rebase after pull if the latter has been invoked with --rebase"""
if opts.get('rebase'): if opts.get('rebase'):
if ui.configbool(b'commands', b'rebase.requiredest'): if ui.configbool(b'commands', b'rebase.requiredest'):
msg = _(b'rebase destination required by configuration') msg = _(b'rebase destination required by configuration')
hint = _(b'use hg pull followed by hg rebase -d DEST') hint = _(b'use hg pull followed by hg rebase -d DEST')
raise error.Abort(msg, hint=hint) raise error.Abort(msg, hint=hint)
with repo.wlock(), repo.lock(): with repo.wlock(), repo.lock():
if opts.get('update'): if opts.get('update'):

mercurial/changelog.py

self._realopener = opener self._realopener = opener
self._delayed = False self._delayed = False
self._delaybuf = None self._delaybuf = None
self._divert = False self._divert = False
self.filteredrevs = frozenset() self.filteredrevs = frozenset()
self._copiesstorage = opener.options.get(b'copies-storage') self._copiesstorage = opener.options.get(b'copies-storage')
def delayupdate(self, tr): def delayupdate(self, tr):
b"delay visibility of index updates to other readers" """delay visibility of index updates to other readers"""
if not self._delayed: if not self._delayed:
if len(self) == 0: if len(self) == 0:
self._divert = True self._divert = True
if self._realopener.exists(self.indexfile + b'.a'): if self._realopener.exists(self.indexfile + b'.a'):
self._realopener.unlink(self.indexfile + b'.a') self._realopener.unlink(self.indexfile + b'.a')
self.opener = _divertopener(self._realopener, self.indexfile) self.opener = _divertopener(self._realopener, self.indexfile)
else: else:
self._delaybuf = [] self._delaybuf = []
self.opener = _delayopener( self.opener = _delayopener(
self._realopener, self.indexfile, self._delaybuf self._realopener, self.indexfile, self._delaybuf
) )
self._delayed = True self._delayed = True
tr.addpending(b'cl-%i' % id(self), self._writepending) tr.addpending(b'cl-%i' % id(self), self._writepending)
tr.addfinalize(b'cl-%i' % id(self), self._finalize) tr.addfinalize(b'cl-%i' % id(self), self._finalize)
def _finalize(self, tr): def _finalize(self, tr):
b"finalize index updates" """finalize index updates"""
self._delayed = False self._delayed = False
self.opener = self._realopener self.opener = self._realopener
# move redirected index data back into place # move redirected index data back into place
if self._divert: if self._divert:
assert not self._delaybuf assert not self._delaybuf
tmpname = self.indexfile + b".a" tmpname = self.indexfile + b".a"
nfile = self.opener.open(tmpname) nfile = self.opener.open(tmpname)
nfile.close() nfile.close()
self.opener.rename(tmpname, self.indexfile, checkambig=True) self.opener.rename(tmpname, self.indexfile, checkambig=True)
elif self._delaybuf: elif self._delaybuf:
fp = self.opener(self.indexfile, b'a', checkambig=True) fp = self.opener(self.indexfile, b'a', checkambig=True)
fp.write(b"".join(self._delaybuf)) fp.write(b"".join(self._delaybuf))
fp.close() fp.close()
self._delaybuf = None self._delaybuf = None
self._divert = False self._divert = False
# split when we're done # split when we're done
self._enforceinlinesize(tr) self._enforceinlinesize(tr)
def _writepending(self, tr): def _writepending(self, tr):
b"create a file containing the unfinalized state for pretxnchangegroup" """create a file containing the unfinalized state for
pretxnchangegroup"""
if self._delaybuf: if self._delaybuf:
# make a temporary copy of the index # make a temporary copy of the index
fp1 = self._realopener(self.indexfile) fp1 = self._realopener(self.indexfile)
pendingfilename = self.indexfile + b".a" pendingfilename = self.indexfile + b".a"
# register as a temp file to ensure cleanup on failure # register as a temp file to ensure cleanup on failure
tr.registertmp(pendingfilename) tr.registertmp(pendingfilename)
# write existing data # write existing data
fp2 = self._realopener(pendingfilename, b"w") fp2 = self._realopener(pendingfilename, b"w")

mercurial/color.py

if ui._colormode == b'win32': if ui._colormode == b'win32':
return w32effects return w32effects
elif ui._colormode is not None: elif ui._colormode is not None:
return _effects return _effects
return {} return {}
def valideffect(ui, effect): def valideffect(ui, effect):
b'Determine if the effect is valid or not.' """Determine if the effect is valid or not."""
return (not ui._terminfoparams and effect in _activeeffects(ui)) or ( return (not ui._terminfoparams and effect in _activeeffects(ui)) or (
effect in ui._terminfoparams or effect[:-11] in ui._terminfoparams effect in ui._terminfoparams or effect[:-11] in ui._terminfoparams
) )
def _effect_str(ui, effect): def _effect_str(ui, effect):
'''Helper function for render_effects().''' '''Helper function for render_effects().'''
for t in text.split(stop): for t in text.split(stop):
if not t: if not t:
continue continue
parts.extend([start, t, stop]) parts.extend([start, t, stop])
return b''.join(parts) return b''.join(parts)
def _render_effects(ui, text, effects): def _render_effects(ui, text, effects):
b'Wrap text in commands to turn on each effect.' """Wrap text in commands to turn on each effect."""
if not text: if not text:
return text return text
if ui._terminfoparams: if ui._terminfoparams:
start = b''.join( start = b''.join(
_effect_str(ui, effect) for effect in [b'none'] + effects.split() _effect_str(ui, effect) for effect in [b'none'] + effects.split()
) )
stop = _effect_str(ui, b'none') stop = _effect_str(ui, b'none')
else: else:

mercurial/context.py

def filectx(self, path, filelog=None): def filectx(self, path, filelog=None):
"""get a file context from the working directory""" """get a file context from the working directory"""
return workingfilectx( return workingfilectx(
self._repo, path, workingctx=self, filelog=filelog self._repo, path, workingctx=self, filelog=filelog
) )
def dirty(self, missing=False, merge=True, branch=True): def dirty(self, missing=False, merge=True, branch=True):
b"check whether a working directory is modified" """check whether a working directory is modified"""
# check subrepos first # check subrepos first
for s in sorted(self.substate): for s in sorted(self.substate):
if self.sub(s).dirty(missing=missing): if self.sub(s).dirty(missing=missing):
return True return True
# check current working dir # check current working dir
return ( return (
(merge and self.p2()) (merge and self.p2())
or (branch and self.branch() != self.p1().branch()) or (branch and self.branch() != self.p1().branch())

mercurial/crecord.py

def firstchild(self): def firstchild(self):
raise NotImplementedError(b"method must be implemented by subclass") raise NotImplementedError(b"method must be implemented by subclass")
def lastchild(self): def lastchild(self):
raise NotImplementedError(b"method must be implemented by subclass") raise NotImplementedError(b"method must be implemented by subclass")
def allchildren(self): def allchildren(self):
b"Return a list of all of the direct children of this node" """Return a list of all of the direct children of this node"""
raise NotImplementedError(b"method must be implemented by subclass") raise NotImplementedError(b"method must be implemented by subclass")
def nextsibling(self): def nextsibling(self):
""" """
Return the closest next item of the same type where there are no items Return the closest next item of the same type where there are no items
of different types between the current item and this closest item. of different types between the current item and this closest item.
If no such item exists, return None. If no such item exists, return None.
""" """
def parentitem(self): def parentitem(self):
""" """
there is no 'real' parent item of a header that can be selected, there is no 'real' parent item of a header that can be selected,
so return None. so return None.
""" """
return None return None
def firstchild(self): def firstchild(self):
b"return the first child of this item, if one exists. otherwise None." """return the first child of this item, if one exists. otherwise
None."""
if len(self.hunks) > 0: if len(self.hunks) > 0:
return self.hunks[0] return self.hunks[0]
else: else:
return None return None
def lastchild(self): def lastchild(self):
b"return the last child of this item, if one exists. otherwise None." """return the last child of this item, if one exists. otherwise
None."""
if len(self.hunks) > 0: if len(self.hunks) > 0:
return self.hunks[-1] return self.hunks[-1]
else: else:
return None return None
def allchildren(self): def allchildren(self):
b"return a list of all of the direct children of this node" """return a list of all of the direct children of this node"""
return self.hunks return self.hunks
def __getattr__(self, name): def __getattr__(self, name):
return getattr(self.nonuiheader, name) return getattr(self.nonuiheader, name)
class uihunkline(patchnode): class uihunkline(patchnode):
b"represents a changed line in a hunk" """represents a changed line in a hunk"""
def __init__(self, linetext, hunk): def __init__(self, linetext, hunk):
self.linetext = linetext self.linetext = linetext
self.applied = True self.applied = True
# the parent hunk to which this line belongs # the parent hunk to which this line belongs
self.hunk = hunk self.hunk = hunk
# folding lines currently is not used/needed, but this flag is needed # folding lines currently is not used/needed, but this flag is needed
# in the previtem method. # in the previtem method.
indexofthisline = self.hunk.changedlines.index(self) indexofthisline = self.hunk.changedlines.index(self)
if indexofthisline > 0: if indexofthisline > 0:
previousline = self.hunk.changedlines[indexofthisline - 1] previousline = self.hunk.changedlines[indexofthisline - 1]
return previousline return previousline
else: else:
return None return None
def parentitem(self): def parentitem(self):
b"return the parent to the current item" """return the parent to the current item"""
return self.hunk return self.hunk
def firstchild(self): def firstchild(self):
b"return the first child of this item, if one exists. otherwise None." """return the first child of this item, if one exists. otherwise
None."""
# hunk-lines don't have children # hunk-lines don't have children
return None return None
def lastchild(self): def lastchild(self):
b"return the last child of this item, if one exists. otherwise None." """return the last child of this item, if one exists. otherwise
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
indexofthishunk = self.header.hunks.index(self) indexofthishunk = self.header.hunks.index(self)
if indexofthishunk > 0: if indexofthishunk > 0:
previoushunk = self.header.hunks[indexofthishunk - 1] previoushunk = self.header.hunks[indexofthishunk - 1]
return previoushunk return previoushunk
else: else:
return None return None
def parentitem(self): def parentitem(self):
b"return the parent to the current item" """return the parent to the current item"""
return self.header return self.header
def firstchild(self): def firstchild(self):
b"return the first child of this item, if one exists. otherwise None." """return the first child of this item, if one exists. otherwise
None."""
if len(self.changedlines) > 0: if len(self.changedlines) > 0:
return self.changedlines[0] return self.changedlines[0]
else: else:
return None return None
def lastchild(self): def lastchild(self):
b"return the last child of this item, if one exists. otherwise None." """return the last child of this item, if one exists. otherwise
None."""
if len(self.changedlines) > 0: if len(self.changedlines) > 0:
return self.changedlines[-1] return self.changedlines[-1]
else: else:
return None return None
def allchildren(self): def allchildren(self):
b"return a list of all of the direct children of this node" """return a list of all of the direct children of this node"""
return self.changedlines return self.changedlines
def countchanges(self): def countchanges(self):
"""changedlines -> (n+,n-)""" """changedlines -> (n+,n-)"""
add = len( add = len(
[ [
l l
for l in self.changedlines for l in self.changedlines
if nextitem is None: if nextitem is None:
break break
else: else:
currentitem = nextitem currentitem = nextitem
self.currentselecteditem = currentitem self.currentselecteditem = currentitem
def updatescroll(self): def updatescroll(self):
b"scroll the screen to fully show the currently-selected" """scroll the screen to fully show the currently-selected"""
selstart = self.selecteditemstartline selstart = self.selecteditemstartline
selend = self.selecteditemendline selend = self.selecteditemendline
padstart = self.firstlineofpadtoprint padstart = self.firstlineofpadtoprint
padend = padstart + self.yscreensize - self.numstatuslines - 1 padend = padstart + self.yscreensize - self.numstatuslines - 1
# 'buffered' pad start/end values which scroll with a certain # 'buffered' pad start/end values which scroll with a certain
# top/bottom context margin # top/bottom context margin
padstartbuffered = padstart + 3 padstartbuffered = padstart + 3
padendbuffered = padend - 3 padendbuffered = padend - 3
if selend > padendbuffered: if selend > padendbuffered:
self.scrolllines(selend - padendbuffered) self.scrolllines(selend - padendbuffered)
elif selstart < padstartbuffered: elif selstart < padstartbuffered:
# negative values scroll in pgup direction # negative values scroll in pgup direction
self.scrolllines(selstart - padstartbuffered) self.scrolllines(selstart - padstartbuffered)
def scrolllines(self, numlines): def scrolllines(self, numlines):
b"scroll the screen up (down) by numlines when numlines >0 (<0)." """scroll the screen up (down) by numlines when numlines >0 (<0)."""
self.firstlineofpadtoprint += numlines self.firstlineofpadtoprint += numlines
if self.firstlineofpadtoprint < 0: if self.firstlineofpadtoprint < 0:
self.firstlineofpadtoprint = 0 self.firstlineofpadtoprint = 0
if self.firstlineofpadtoprint > self.numpadlines - 1: if self.firstlineofpadtoprint > self.numpadlines - 1:
self.firstlineofpadtoprint = self.numpadlines - 1 self.firstlineofpadtoprint = self.numpadlines - 1
def toggleapply(self, item=None): def toggleapply(self, item=None):
""" """
# set the applied and partial status of the header if needed # set the applied and partial status of the header if needed
else: # some/all parent siblings are applied else: # some/all parent siblings are applied
item.hunk.header.applied = True item.hunk.header.applied = True
item.hunk.header.partial = ( item.hunk.header.partial = (
someparentsiblingspartial or not allparentsiblingsapplied someparentsiblingspartial or not allparentsiblingsapplied
) )
def toggleall(self): def toggleall(self):
b"toggle the applied flag of all items." """toggle the applied flag of all items."""
if self.waslasttoggleallapplied: # then unapply them this time if self.waslasttoggleallapplied: # then unapply them this time
for item in self.headerlist: for item in self.headerlist:
if item.applied: if item.applied:
self.toggleapply(item) self.toggleapply(item)
else: else:
for item in self.headerlist: for item in self.headerlist:
if not item.applied: if not item.applied:
self.toggleapply(item) self.toggleapply(item)
self.waslasttoggleallapplied = not self.waslasttoggleallapplied self.waslasttoggleallapplied = not self.waslasttoggleallapplied
def toggleallbetween(self): def toggleallbetween(self):
b"toggle applied on or off for all items in range [lastapplied,current]." """toggle applied on or off for all items in range [lastapplied,
current]. """
if ( if (
not self.lastapplieditem not self.lastapplieditem
or self.currentselecteditem == self.lastapplieditem or self.currentselecteditem == self.lastapplieditem
): ):
# Treat this like a normal 'x'/' ' # Treat this like a normal 'x'/' '
self.toggleapply() self.toggleapply()
return return
# This does *not* invert each item (i.e. middleitem stays marked/on) # This does *not* invert each item (i.e. middleitem stays marked/on)
desiredstate = not self.currentselecteditem.applied desiredstate = not self.currentselecteditem.applied
while nextitem != enditem.nextitem(): while nextitem != enditem.nextitem():
if nextitem.applied != desiredstate: if nextitem.applied != desiredstate:
self.toggleapply(item=nextitem) self.toggleapply(item=nextitem)
nextitem = nextitem.nextitem() nextitem = nextitem.nextitem()
def togglefolded(self, item=None, foldparent=False): def togglefolded(self, item=None, foldparent=False):
b"toggle folded flag of specified item (defaults to currently selected)" """toggle folded flag of specified item (defaults to currently
selected)"""
if item is None: if item is None:
item = self.currentselecteditem item = self.currentselecteditem
if foldparent or (isinstance(item, uiheader) and item.neverunfolded): if foldparent or (isinstance(item, uiheader) and item.neverunfolded):
if not isinstance(item, uiheader): if not isinstance(item, uiheader):
# we need to select the parent item in this case # we need to select the parent item in this case
self.currentselecteditem = item = item.parentitem() self.currentselecteditem = item = item.parentitem()
elif item.neverunfolded: elif item.neverunfolded:
item.neverunfolded = False item.neverunfolded = False
self.chunkpad, linestr, pair=colorpair, towin=towin self.chunkpad, linestr, pair=colorpair, towin=towin
) )
return outstr return outstr
def printhunklinesbefore( def printhunklinesbefore(
self, hunk, selected=False, towin=True, ignorefolding=False self, hunk, selected=False, towin=True, ignorefolding=False
): ):
b"includes start/end line indicator" """includes start/end line indicator"""
outstr = b"" outstr = b""
# where hunk is in list of siblings # where hunk is in list of siblings
hunkindex = hunk.header.hunks.index(hunk) hunkindex = hunk.header.hunks.index(hunk)
if hunkindex != 0: if hunkindex != 0:
# add separating line before headers # add separating line before headers
outstr += self.printstring( outstr += self.printstring(
self.chunkpad, b' ' * self.xscreensize, towin=towin, align=False self.chunkpad, b' ' * self.xscreensize, towin=towin, align=False
# temporarily disable printing to windows by printstring # temporarily disable printing to windows by printstring
patchdisplaystring = self.printitem( patchdisplaystring = self.printitem(
item, ignorefolding, recursechildren, towin=False item, ignorefolding, recursechildren, towin=False
) )
numlines = len(patchdisplaystring) // self.xscreensize numlines = len(patchdisplaystring) // self.xscreensize
return numlines return numlines
def sigwinchhandler(self, n, frame): def sigwinchhandler(self, n, frame):
b"handle window resizing" """handle window resizing"""
try: try:
curses.endwin() curses.endwin()
self.xscreensize, self.yscreensize = scmutil.termsize(self.ui) self.xscreensize, self.yscreensize = scmutil.termsize(self.ui)
self.statuswin.resize(self.numstatuslines, self.xscreensize) self.statuswin.resize(self.numstatuslines, self.xscreensize)
self.numpadlines = self.getnumlinesdisplayed(ignorefolding=True) + 1 self.numpadlines = self.getnumlinesdisplayed(ignorefolding=True) + 1
self.chunkpad = curses.newpad(self.numpadlines, self.xscreensize) self.chunkpad = curses.newpad(self.numpadlines, self.xscreensize)
except curses.error: except curses.error:
pass pass
else: else:
# just apply a select few (safe?) attributes # just apply a select few (safe?) attributes
for textattrib in (curses.A_UNDERLINE, curses.A_BOLD): for textattrib in (curses.A_UNDERLINE, curses.A_BOLD):
if textattrib in attrlist: if textattrib in attrlist:
colorpair |= textattrib colorpair |= textattrib
return colorpair return colorpair
def initcolorpair(self, *args, **kwargs): def initcolorpair(self, *args, **kwargs):
b"same as getcolorpair." """same as getcolorpair."""
self.getcolorpair(*args, **kwargs) self.getcolorpair(*args, **kwargs)
def helpwindow(self): def helpwindow(self):
b"print a help window to the screen. exit after any keypress." """print a help window to the screen. exit after any keypress."""
helptext = _( helptext = _(
""" [press any key to return to the patch-display] """ [press any key to return to the patch-display]
crecord allows you to interactively choose among the changes you have made, crecord allows you to interactively choose among the changes you have made,
and confirm only those changes you select for further processing by the command and confirm only those changes you select for further processing by the command
you are running (commit/shelve/revert), after confirming the selected you are running (commit/shelve/revert), after confirming the selected
changes, the unselected changes are still present in your working copy, so you changes, the unselected changes are still present in your working copy, so you
can use crecord multiple times to split large changes into smaller changesets. can use crecord multiple times to split large changes into smaller changesets.
helpwin.refresh() helpwin.refresh()
try: try:
with self.ui.timeblockedsection(b'crecord'): with self.ui.timeblockedsection(b'crecord'):
helpwin.getkey() helpwin.getkey()
except curses.error: except curses.error:
pass pass
def commitMessageWindow(self): def commitMessageWindow(self):
b"Create a temporary commit message editing window on the screen." """Create a temporary commit message editing window on the screen."""
curses.raw() curses.raw()
curses.def_prog_mode() curses.def_prog_mode()
curses.endwin() curses.endwin()
self.commenttext = self.ui.edit(self.commenttext, self.ui.username()) self.commenttext = self.ui.edit(self.commenttext, self.ui.username())
curses.cbreak() curses.cbreak()
self.stdscr.refresh() self.stdscr.refresh()
self.stdscr.keypad(1) # allow arrow-keys to continue to function self.stdscr.keypad(1) # allow arrow-keys to continue to function
break break
else: else:
currentitem = nextitem currentitem = nextitem
self.currentselecteditem = currentitem self.currentselecteditem = currentitem
self.recenterdisplayedarea() self.recenterdisplayedarea()
def confirmationwindow(self, windowtext): def confirmationwindow(self, windowtext):
b"display an informational window, then wait for and return a keypress." """display an informational window, then wait for and return a
keypress."""
confirmwin = curses.newwin(self.yscreensize, 0, 0, 0) confirmwin = curses.newwin(self.yscreensize, 0, 0, 0)
try: try:
lines = windowtext.split(b"\n") lines = windowtext.split(b"\n")
for line in lines: for line in lines:
self.printstring(confirmwin, line, pairname=b"selected") self.printstring(confirmwin, line, pairname=b"selected")
except curses.error: except curses.error:
pass pass

mercurial/dispatch.py

self.ui.warnnoi18n(b'error in exit handlers:\n') self.ui.warnnoi18n(b'error in exit handlers:\n')
self.ui.traceback(force=True) self.ui.traceback(force=True)
finally: finally:
if exc is not None: if exc is not None:
raise exc raise exc
def run(): def run():
b"run the command in sys.argv" """run the command in sys.argv"""
initstdio() initstdio()
with tracing.log('parse args into request'): with tracing.log('parse args into request'):
req = request(pycompat.sysargv[1:]) req = request(pycompat.sysargv[1:])
err = None err = None
try: try:
status = dispatch(req) status = dispatch(req)
except error.StdioError as e: except error.StdioError as e:
err = e err = e

mercurial/encoding.py

environ.get(b"HGENCODINGAMBIGUOUS", b"narrow") == b"wide" environ.get(b"HGENCODINGAMBIGUOUS", b"narrow") == b"wide"
and b"WFA" and b"WFA"
or b"WF" or b"WF"
) )
def colwidth(s): def colwidth(s):
# type: (bytes) -> int # type: (bytes) -> int
b"Find the column width of a string for display in the local encoding" """Find the column width of a string for display in the local encoding"""
return ucolwidth(s.decode(_sysstr(encoding), 'replace')) return ucolwidth(s.decode(_sysstr(encoding), 'replace'))
def ucolwidth(d): def ucolwidth(d):
# type: (Text) -> int # type: (Text) -> int
b"Find the column width of a Unicode string for display" """Find the column width of a Unicode string for display"""
eaw = getattr(unicodedata, 'east_asian_width', None) eaw = getattr(unicodedata, 'east_asian_width', None)
if eaw is not None: if eaw is not None:
return sum([eaw(c) in _wide and 2 or 1 for c in d]) return sum([eaw(c) in _wide and 2 or 1 for c in d])
return len(d) return len(d)
def getcols(s, start, c): def getcols(s, start, c):
# type: (bytes, int, int) -> bytes # type: (bytes, int, int) -> bytes
usub = uslice(i) usub = uslice(i)
if ucolwidth(usub) <= width: if ucolwidth(usub) <= width:
return concat(usub.encode(_sysstr(encoding))) return concat(usub.encode(_sysstr(encoding)))
return ellipsis # no enough room for multi-column characters return ellipsis # no enough room for multi-column characters
def lower(s): def lower(s):
# type: (bytes) -> bytes # type: (bytes) -> bytes
b"best-effort encoding-aware case-folding of local string s" """best-effort encoding-aware case-folding of local string s"""
try: try:
return asciilower(s) return asciilower(s)
except UnicodeDecodeError: except UnicodeDecodeError:
pass pass
try: try:
if isinstance(s, localstr): if isinstance(s, localstr):
u = s._utf8.decode("utf-8") u = s._utf8.decode("utf-8")
else: else:
u = s.decode(_sysstr(encoding), _sysstr(encodingmode)) u = s.decode(_sysstr(encoding), _sysstr(encodingmode))
lu = u.lower() lu = u.lower()
if u == lu: if u == lu:
return s # preserve localstring return s # preserve localstring
return lu.encode(_sysstr(encoding)) return lu.encode(_sysstr(encoding))
except UnicodeError: except UnicodeError:
return s.lower() # we don't know how to fold this except in ASCII return s.lower() # we don't know how to fold this except in ASCII
except LookupError as k: except LookupError as k:
raise error.Abort(k, hint=b"please check your locale settings") raise error.Abort(k, hint=b"please check your locale settings")
def upper(s): def upper(s):
# type: (bytes) -> bytes # type: (bytes) -> bytes
b"best-effort encoding-aware case-folding of local string s" """best-effort encoding-aware case-folding of local string s"""
try: try:
return asciiupper(s) return asciiupper(s)
except UnicodeDecodeError: except UnicodeDecodeError:
return upperfallback(s) return upperfallback(s)
def upperfallback(s): def upperfallback(s):
# type: (Any) -> Any # type: (Any) -> Any

mercurial/filemerge.py

if not changedelete and len(tools): if not changedelete and len(tools):
# any tool is rejected by capability for symlink or binary # any tool is rejected by capability for symlink or binary
ui.warn(_(b"no tool found to merge %s\n") % path) ui.warn(_(b"no tool found to merge %s\n") % path)
return b":prompt", None return b":prompt", None
return b":merge", None return b":merge", None
def _eoltype(data): def _eoltype(data):
b"Guess the EOL type of a file" """Guess the EOL type of a file"""
if b'\0' in data: # binary if b'\0' in data: # binary
return None return None
if b'\r\n' in data: # Windows if b'\r\n' in data: # Windows
return b'\r\n' return b'\r\n'
if b'\r' in data: # Old Mac if b'\r' in data: # Old Mac
return b'\r' return b'\r'
if b'\n' in data: # UNIX if b'\n' in data: # UNIX
return b'\n' return b'\n'
return None # unknown return None # unknown
def _matcheol(file, back): def _matcheol(file, back):
b"Convert EOL markers in a file to match origfile" """Convert EOL markers in a file to match origfile"""
tostyle = _eoltype(back.data()) # No repo.wread filters? tostyle = _eoltype(back.data()) # No repo.wread filters?
if tostyle: if tostyle:
data = util.readfile(file) data = util.readfile(file)
style = _eoltype(data) style = _eoltype(data)
if style: if style:
newdata = data.replace(style, tostyle) newdata = data.replace(style, tostyle)
if newdata != data: if newdata != data:
util.writefile(file, newdata) util.writefile(file, newdata)

mercurial/hg.py

_(b'.hgsubstate is corrupt in revision %s\n') _(b'.hgsubstate is corrupt in revision %s\n')
% node.short(ctx.node()) % node.short(ctx.node())
) )
return ret return ret
def remoteui(src, opts): def remoteui(src, opts):
b'build a remote ui from ui or repo and opts' """build a remote ui from ui or repo and opts"""
if util.safehasattr(src, b'baseui'): # looks like a repository if util.safehasattr(src, b'baseui'): # looks like a repository
dst = src.baseui.copy() # drop repo-specific config dst = src.baseui.copy() # drop repo-specific config
src = src.ui # copy target options from repo src = src.ui # copy target options from repo
else: # assume it's a global ui object else: # assume it's a global ui object
dst = src.copy() # keep all global options dst = src.copy() # keep all global options
# copy ssh-specific options # copy ssh-specific options
for o in b'ssh', b'remotecmd': for o in b'ssh', b'remotecmd':

mercurial/interfaces/dirstate.py

# TODO: all these private methods and attributes should be made # TODO: all these private methods and attributes should be made
# public or removed from the interface. # public or removed from the interface.
_ignore = interfaceutil.Attribute("""Matcher for ignored files.""") _ignore = interfaceutil.Attribute("""Matcher for ignored files.""")
def _ignorefiles(): def _ignorefiles():
"""Return a list of files containing patterns to ignore.""" """Return a list of files containing patterns to ignore."""
def _ignorefileandline(f): def _ignorefileandline(f):
b"Given a file `f`, return the ignore file and line that ignores it." """Given a file `f`, return the ignore file and line that ignores it."""
_checklink = interfaceutil.Attribute("""Callable for checking symlinks.""") _checklink = interfaceutil.Attribute("""Callable for checking symlinks.""")
_checkexec = interfaceutil.Attribute("""Callable for checking exec bits.""") _checkexec = interfaceutil.Attribute("""Callable for checking exec bits.""")
@contextlib.contextmanager @contextlib.contextmanager
def parentchange(): def parentchange():
'''Context manager for handling dirstate parents. '''Context manager for handling dirstate parents.

mercurial/merge.py

] ]
progress.complete() progress.complete()
assert len(getfiledata) == (len(actions[ACTION_GET]) if wantfiledata else 0) assert len(getfiledata) == (len(actions[ACTION_GET]) if wantfiledata else 0)
return updateresult(updated, merged, removed, unresolved), getfiledata return updateresult(updated, merged, removed, unresolved), getfiledata
def recordupdates(repo, actions, branchmerge, getfiledata): def recordupdates(repo, actions, branchmerge, getfiledata):
b"record merge actions to the dirstate" """record merge actions to the dirstate"""
# remove (must come first) # remove (must come first)
for f, args, msg in actions.get(ACTION_REMOVE, []): for f, args, msg in actions.get(ACTION_REMOVE, []):
if branchmerge: if branchmerge:
repo.dirstate.remove(f) repo.dirstate.remove(f)
else: else:
repo.dirstate.drop(f) repo.dirstate.drop(f)
# forget (must come first) # forget (must come first)

mercurial/parser.py

class parser(object): class parser(object):
def __init__(self, elements, methods=None): def __init__(self, elements, methods=None):
self._elements = elements self._elements = elements
self._methods = methods self._methods = methods
self.current = None self.current = None
def _advance(self): def _advance(self):
b'advance the tokenizer' """advance the tokenizer"""
t = self.current t = self.current
self.current = next(self._iter, None) self.current = next(self._iter, None)
return t return t
def _hasnewterm(self): def _hasnewterm(self):
b'True if next token may start new term' """True if next token may start new term"""
return any(self._elements[self.current[0]][1:3]) return any(self._elements[self.current[0]][1:3])
def _match(self, m): def _match(self, m):
b'make sure the tokenizer matches an end condition' """make sure the tokenizer matches an end condition"""
if self.current[0] != m: if self.current[0] != m:
raise error.ParseError( raise error.ParseError(
_(b"unexpected token: %s") % self.current[0], self.current[2] _(b"unexpected token: %s") % self.current[0], self.current[2]
) )
self._advance() self._advance()
def _parseoperand(self, bind, m=None): def _parseoperand(self, bind, m=None):
b'gather right-hand-side operand until an end condition or binding met' """gather right-hand-side operand until an end condition or binding
met"""
if m and self.current[0] == m: if m and self.current[0] == m:
expr = None expr = None
else: else:
expr = self._parse(bind) expr = self._parse(bind)
if m: if m:
self._match(m) self._match(m)
return expr return expr
expr = (suffix, expr) expr = (suffix, expr)
elif infix: elif infix:
expr = (infix[0], expr, self._parseoperand(*infix[1:])) expr = (infix[0], expr, self._parseoperand(*infix[1:]))
else: else:
raise error.ParseError(_(b"not an infix: %s") % token, pos) raise error.ParseError(_(b"not an infix: %s") % token, pos)
return expr return expr
def parse(self, tokeniter): def parse(self, tokeniter):
b'generate a parse tree from tokens' """generate a parse tree from tokens"""
self._iter = tokeniter self._iter = tokeniter
self._advance() self._advance()
res = self._parse() res = self._parse()
token, value, pos = self.current token, value, pos = self.current
return res, pos return res, pos
def eval(self, tree): def eval(self, tree):
b'recursively evaluate a parse tree using node methods' """recursively evaluate a parse tree using node methods"""
if not isinstance(tree, tuple): if not isinstance(tree, tuple):
return tree return tree
return self._methods[tree[0]](*[self.eval(t) for t in tree[1:]]) return self._methods[tree[0]](*[self.eval(t) for t in tree[1:]])
def __call__(self, tokeniter): def __call__(self, tokeniter):
b'parse tokens into a parse tree and evaluate if methods given' """parse tokens into a parse tree and evaluate if methods given"""
t = self.parse(tokeniter) t = self.parse(tokeniter)
if self._methods: if self._methods:
return self.eval(t) return self.eval(t)
return t return t
def splitargspec(spec): def splitargspec(spec):
"""Parse spec of function arguments into (poskeys, varkey, keys, optkey) """Parse spec of function arguments into (poskeys, varkey, keys, optkey)

mercurial/patch.py

if self.lena and oldstart > 0: if self.lena and oldstart > 0:
oldstart -= 1 oldstart -= 1
if self.lenb and newstart > 0: if self.lenb and newstart > 0:
newstart -= 1 newstart -= 1
return old, oldstart, new, newstart return old, oldstart, new, newstart
class binhunk(object): class binhunk(object):
b'A binary patch file.' """A binary patch file."""
def __init__(self, lr, fname): def __init__(self, lr, fname):
self.text = None self.text = None
self.delta = False self.delta = False
self.hunk = [b'GIT binary patch\n'] self.hunk = [b'GIT binary patch\n']
self._fname = fname self._fname = fname
self._read(lr) self._read(lr)

mercurial/subrepo.py

continue continue
if ref.startswith(b'refs/remotes/') and ref.endswith(b'/HEAD'): if ref.startswith(b'refs/remotes/') and ref.endswith(b'/HEAD'):
continue # ignore remote/HEAD redirects continue # ignore remote/HEAD redirects
branch2rev[ref] = revision branch2rev[ref] = revision
rev2branch.setdefault(revision, []).append(ref) rev2branch.setdefault(revision, []).append(ref)
return branch2rev, rev2branch return branch2rev, rev2branch
def _gittracking(self, branches): def _gittracking(self, branches):
b'return map of remote branch to local tracking branch' """return map of remote branch to local tracking branch"""
# assumes no more than one local tracking branch for each remote # assumes no more than one local tracking branch for each remote
tracking = {} tracking = {}
for b in branches: for b in branches:
if b.startswith(b'refs/remotes/'): if b.startswith(b'refs/remotes/'):
continue continue
bname = b.split(b'/', 2)[2] bname = b.split(b'/', 2)[2]
remote = self._gitcommand([b'config', b'branch.%s.remote' % bname]) remote = self._gitcommand([b'config', b'branch.%s.remote' % bname])
if remote: if remote:

mercurial/ui.py

self.debug( self.debug(
b'ignoring untrusted configuration option ' b'ignoring untrusted configuration option '
b'%s:%s.%s = %s\n' % (section, name, k, uvalue) b'%s:%s.%s = %s\n' % (section, name, k, uvalue)
) )
return main, sub return main, sub
def configpath(self, section, name, default=_unset, untrusted=False): def configpath(self, section, name, default=_unset, untrusted=False):
b'get a path config item, expanded relative to repo root or config file' """get a path config item, expanded relative to repo root or config
file"""
v = self.config(section, name, default, untrusted) v = self.config(section, name, default, untrusted)
if v is None: if v is None:
return None return None
if not os.path.isabs(v) or b"://" not in v: if not os.path.isabs(v) or b"://" not in v:
src = self.configsource(section, name, untrusted) src = self.configsource(section, name, untrusted)
if b':' in src: if b':' in src:
base = os.path.dirname(src.rsplit(b':')[0]) base = os.path.dirname(src.rsplit(b':')[0])
v = os.path.join(base, os.path.expanduser(v)) v = os.path.join(base, os.path.expanduser(v))

mercurial/utils/procutil.py

_filtertable = { _filtertable = {
b'tempfile:': tempfilter, b'tempfile:': tempfilter,
b'pipe:': pipefilter, b'pipe:': pipefilter,
} }
def filter(s, cmd): def filter(s, cmd):
b"filter a string through a command that transforms its input to its output" """filter a string through a command that transforms its input to its
output"""
for name, fn in pycompat.iteritems(_filtertable): for name, fn in pycompat.iteritems(_filtertable):
if cmd.startswith(name): if cmd.startswith(name):
return fn(s, cmd[len(name) :].lstrip()) return fn(s, cmd[len(name) :].lstrip())
return pipefilter(s, cmd) return pipefilter(s, cmd)
_hgexecutable = None _hgexecutable = None
os.dup2(f.fileno(), uif.fileno()) os.dup2(f.fileno(), uif.fileno())
f.close() f.close()
def shellenviron(environ=None): def shellenviron(environ=None):
"""return environ with optional override, useful for shelling out""" """return environ with optional override, useful for shelling out"""
def py2shell(val): def py2shell(val):
b'convert python object into string that is useful to shell' """convert python object into string that is useful to shell"""
if val is None or val is False: if val is None or val is False:
return b'0' return b'0'
if val is True: if val is True:
return b'1' return b'1'
return pycompat.bytestr(val) return pycompat.bytestr(val)
env = dict(encoding.environ) env = dict(encoding.environ)
if environ: if environ:

mercurial/windows.py

An extension from PATHEXT is found and added if not present. An extension from PATHEXT is found and added if not present.
If command isn't found None is returned.''' If command isn't found None is returned.'''
pathext = encoding.environ.get(b'PATHEXT', b'.COM;.EXE;.BAT;.CMD') pathext = encoding.environ.get(b'PATHEXT', b'.COM;.EXE;.BAT;.CMD')
pathexts = [ext for ext in pathext.lower().split(pycompat.ospathsep)] pathexts = [ext for ext in pathext.lower().split(pycompat.ospathsep)]
if os.path.splitext(command)[1].lower() in pathexts: if os.path.splitext(command)[1].lower() in pathexts:
pathexts = [b''] pathexts = [b'']
def findexisting(pathcommand): def findexisting(pathcommand):
b'Will append extension (if needed) and return existing file' """Will append extension (if needed) and return existing file"""
for ext in pathexts: for ext in pathexts:
executable = pathcommand + ext executable = pathcommand + ext
if os.path.exists(executable): if os.path.exists(executable):
return executable return executable
return None return None
if pycompat.ossep in command: if pycompat.ossep in command:
return findexisting(command) return findexisting(command)