This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7306

cleanup: remove pointless r-prefixes on single-quoted strings
ClosedPublic

Authored by durin42 on Nov 7 2019, 2:36 PM.

Details

Reviewers
indygreg
martinvonz
Group Reviewers
hg-reviewers
Commits
rHG9f70512ae2cf: cleanup: remove pointless r-prefixes on single-quoted strings
rHG2fe6121c630a: cleanup: remove pointless r-prefixes on single-quoted strings
Summary

This is the promised second step on single-quoted strings. These had
existed because our source transformer didn't turn r'' into b'', so we
had tagged some strings as r-strings to get "native" strings on both
Pythons. Now that the transformer is gone, we can dispense with this
nonsense.

Methodology:

I ran

hg locate 'set:added() or modified() or clean()' | egrep '.*\.py$'  | xargs egrep --color=never -n  -- \[\^b\]\[\^a-z\]r\'\[\^\'\\\\\]\*\'\[\^\'\

in an emacs grep-mode buffer, and then used a keyboard macro to
iterate over the results and remove the r prefix as needed.

  1. skip-blame removing unneeded r prefixes left over from Python 3 migration.

Diff Detail

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

Revision Contents
Changeset List

PathPackages
Mcontrib/hgclient.py (2 lines)
Mcontrib/perf.py (10 lines)
Mcontrib/python3-ratchet.py (2 lines)
Mdoc/gendoc.py (2 lines)
Mhgdemandimport/demandimportpy2.py (4 lines)
Mhgext/acl.py (10 lines)
Mhgext/beautifygraph.py (2 lines)
Mhgext/blackbox.py (2 lines)
Mhgext/bookflow.py (2 lines)
Mhgext/bugzilla.py (2 lines)
Mhgext/churn.py (6 lines)
Mhgext/commitextras.py (4 lines)
Mhgext/convert/common.py (2 lines)
Mhgext/convert/gnuarch.py (10 lines)
Mhgext/convert/monotone.py (2 lines)
Mhgext/convert/subversion.py (8 lines)
Mhgext/extdiff.py (2 lines)
Mhgext/fastannotate/commands.py (12 lines)
Mhgext/githelp.py (4 lines)
Mhgext/gpg.py (6 lines)
Mhgext/graphlog.py (2 lines)
Mhgext/hgk.py (14 lines)
Mhgext/histedit.py (6 lines)
Mhgext/infinitepush/__init__.py (8 lines)
Mhgext/infinitepush/common.py (2 lines)
Mhgext/journal.py (6 lines)
Mhgext/keyword.py (8 lines)
Mhgext/largefiles/lfcommands.py (2 lines)
Mhgext/largefiles/overrides.py (40 lines)
Mhgext/largefiles/proto.py (6 lines)
Mhgext/lfs/__init__.py (8 lines)
Mhgext/lfs/blobstore.py (24 lines)
Mhgext/lfs/wireprotolfsserver.py (52 lines)
Mhgext/mq.py (38 lines)
Mhgext/narrow/narrowbundle2.py (8 lines)
Mhgext/narrow/narrowcommands.py (12 lines)
Mhgext/narrow/narrowwirepeer.py (6 lines)
Mhgext/notify.py (22 lines)
Mhgext/patchbomb.py (36 lines)
Mhgext/phabricator.py (22 lines)
Mhgext/rebase.py (18 lines)
Mhgext/record.py (6 lines)
Mhgext/remotefilelog/__init__.py (30 lines)
Mhgext/remotefilelog/basepack.py (16 lines)
Mhgext/remotefilelog/basestore.py (4 lines)
Mhgext/remotefilelog/contentstore.py (4 lines)
Mhgext/remotefilelog/debugcommands.py (14 lines)
Mhgext/remotefilelog/metadatastore.py (4 lines)
Mhgext/remotefilelog/remotefilectx.py (20 lines)
Mhgext/remotefilelog/repack.py (16 lines)
Mhgext/remotefilelog/shallowbundle.py (2 lines)
Mhgext/share.py (2 lines)
Mhgext/sparse.py (10 lines)
Mhgext/transplant.py (4 lines)
Mhgext/zeroconf/Zeroconf.py (6 lines)
Mhgext/zeroconf/__init__.py (24 lines)
Mmercurial/ancestor.py (2 lines)
Mmercurial/archival.py (6 lines)
Mmercurial/branchmap.py (8 lines)
Mmercurial/bundle2.py (16 lines)
Mmercurial/bundlerepo.py (4 lines)
Mmercurial/changelog.py (8 lines)
Mmercurial/chgserver.py (6 lines)
Mmercurial/cmdutil.py (6 lines)
Mmercurial/color.py (28 lines)
Mmercurial/commands.py (36 lines)
Mmercurial/commandserver.py (8 lines)
Mmercurial/config.py (2 lines)
Mmercurial/context.py (24 lines)
Mmercurial/crecord.py (4 lines)
Mmercurial/debugcommands.py (82 lines)
Mmercurial/dirstate.py (4 lines)
Mmercurial/dispatch.py (8 lines)
Mmercurial/encoding.py (8 lines)
Mmercurial/error.py (2 lines)
Mmercurial/exchange.py (38 lines)
Mmercurial/extensions.py (2 lines)
Mmercurial/help.py (2 lines)
Mmercurial/hgweb/__init__.py (18 lines)
Mmercurial/hgweb/common.py (4 lines)
Mmercurial/hgweb/server.py (87 lines)
Mmercurial/hgweb/wsgicgi.py (30 lines)
Mmercurial/httppeer.py (30 lines)
Mmercurial/i18n.py (4 lines)
Mmercurial/keepalive.py (16 lines)
Mmercurial/linelog.py (10 lines)
Mmercurial/localrepo.py (22 lines)
Mmercurial/lsprof.py (4 lines)
Mmercurial/mail.py (8 lines)
Mmercurial/manifest.py (2 lines)
Mmercurial/match.py (2 lines)
Mmercurial/mdiff.py (4 lines)
Mmercurial/obsolete.py (14 lines)
Mmercurial/patch.py (14 lines)
Mmercurial/policy.py (50 lines)
Mmercurial/posix.py (8 lines)
Mmercurial/profiling.py (4 lines)
Mmercurial/pure/charencode.py (2 lines)
Mmercurial/pure/osutil.py (6 lines)
Mmercurial/pycompat.py (6 lines)
Mmercurial/repoview.py (16 lines)
Mmercurial/revlog.py (12 lines)
Mmercurial/revlogutils/sidedata.py (4 lines)
Mmercurial/scmposix.py (2 lines)
Mmercurial/scmutil.py (2 lines)
Mmercurial/setdiscovery.py (2 lines)
Mmercurial/smartset.py (8 lines)
Mmercurial/sslutil.py (28 lines)
Mmercurial/statichttprepo.py (2 lines)
Mmercurial/statprof.py (28 lines)
Mmercurial/store.py (2 lines)
Mmercurial/subrepo.py (74 lines)
Mmercurial/testing/storage.py (24 lines)
Mmercurial/transaction.py (8 lines)
Mmercurial/ui.py (28 lines)
Mmercurial/url.py (16 lines)
Mmercurial/urllibcompat.py (4 lines)
Mmercurial/util.py (260 lines)
Mmercurial/utils/cborutil.py (18 lines)
Mmercurial/utils/compression.py (3 lines)
Mmercurial/utils/dateutil.py (2 lines)
Mmercurial/utils/procutil.py (14 lines)
Mmercurial/utils/stringutil.py (4 lines)
Mmercurial/vfs.py (6 lines)
Mmercurial/win32.py (88 lines)
Mmercurial/windows.py (26 lines)
Mmercurial/wireprotoframing.py (26 lines)
Mmercurial/wireprotov1peer.py (4 lines)
Mmercurial/wireprotov2peer.py (2 lines)
Mmercurial/worker.py (4 lines)
Mtests/fakedirstatewritetime.py (4 lines)
Mtests/pullext.py (8 lines)
Mtests/test-parseindex2.py (2 lines)
Mtests/test-wsgirequest.py (75 lines)

Diff 17722

contrib/hgclient.py

def connectpipe(path=None, extraargs=()): def connectpipe(path=None, extraargs=()):
cmdline = [b'hg', b'serve', b'--cmdserver', b'pipe'] cmdline = [b'hg', b'serve', b'--cmdserver', b'pipe']
if path: if path:
cmdline += [b'-R', path] cmdline += [b'-R', path]
cmdline.extend(extraargs) cmdline.extend(extraargs)
def tonative(cmdline): def tonative(cmdline):
if os.name != r'nt': if os.name != 'nt':
return cmdline return cmdline
return [arg.decode("utf-8") for arg in cmdline] return [arg.decode("utf-8") for arg in cmdline]
server = subprocess.Popen( server = subprocess.Popen(
tonative(cmdline), stdin=subprocess.PIPE, stdout=subprocess.PIPE tonative(cmdline), stdin=subprocess.PIPE, stdout=subprocess.PIPE
) )
return server return server

contrib/perf.py

obj = obj.unfiltered() obj = obj.unfiltered()
if attrname in vars(obj): if attrname in vars(obj):
delattr(obj, attrname) delattr(obj, attrname)
obj._filecache.pop(attrname, None) obj._filecache.pop(attrname, None)
def clearchangelog(repo): def clearchangelog(repo):
if repo is not repo.unfiltered(): if repo is not repo.unfiltered():
object.__setattr__(repo, r'_clcachekey', None) object.__setattr__(repo, '_clcachekey', None)
object.__setattr__(repo, r'_clcache', None) object.__setattr__(repo, '_clcache', None)
clearfilecache(repo.unfiltered(), 'changelog') clearfilecache(repo.unfiltered(), 'changelog')
# perf commands # perf commands
@command(b'perfwalk', formatteropts) @command(b'perfwalk', formatteropts)
def perfwalk(ui, repo, *pats, **opts): def perfwalk(ui, repo, *pats, **opts):
@command(b'perfstartup', formatteropts) @command(b'perfstartup', formatteropts)
def perfstartup(ui, repo, **opts): def perfstartup(ui, repo, **opts):
opts = _byteskwargs(opts) opts = _byteskwargs(opts)
timer, fm = gettimer(ui, opts) timer, fm = gettimer(ui, opts)
def d(): def d():
if os.name != r'nt': if os.name != 'nt':
os.system( os.system(
b"HGRCPATH= %s version -q > /dev/null" % fsencode(sys.argv[0]) b"HGRCPATH= %s version -q > /dev/null" % fsencode(sys.argv[0])
) )
else: else:
os.environ[r'HGRCPATH'] = r' ' os.environ['HGRCPATH'] = r' '
os.system("%s version -q > NUL" % sys.argv[0]) os.system("%s version -q > NUL" % sys.argv[0])
timer(d) timer(d)
fm.end() fm.end()
@command(b'perfparents', formatteropts) @command(b'perfparents', formatteropts)
def perfparents(ui, repo, **opts): def perfparents(ui, repo, **opts):
raise error.Abort( raise error.Abort(
b"perftemplating not available with this Mercurial", b"perftemplating not available with this Mercurial",
hint=b"use 4.3 or later", hint=b"use 4.3 or later",
) )
opts = _byteskwargs(opts) opts = _byteskwargs(opts)
nullui = ui.copy() nullui = ui.copy()
nullui.fout = open(os.devnull, r'wb') nullui.fout = open(os.devnull, 'wb')
nullui.disablepager() nullui.disablepager()
revs = opts.get(b'rev') revs = opts.get(b'rev')
if not revs: if not revs:
revs = [b'all()'] revs = [b'all()']
revs = list(scmutil.revrange(repo, revs)) revs = list(scmutil.revrange(repo, revs))
defaulttemplate = ( defaulttemplate = (
b'{date|shortdate} [{rev}:{node|short}]' b'{date|shortdate} [{rev}:{node|short}]'

contrib/python3-ratchet.py

'--working-tests', help='List of tests that already work in Python 3.' '--working-tests', help='List of tests that already work in Python 3.'
) )
p.add_argument( p.add_argument(
'--commit-to-repo', '--commit-to-repo',
help='If set, commit newly fixed tests to the given repo', help='If set, commit newly fixed tests to the given repo',
) )
p.add_argument( p.add_argument(
'-j', '-j',
default=os.sysconf(r'SC_NPROCESSORS_ONLN'), default=os.sysconf('SC_NPROCESSORS_ONLN'),
type=int, type=int,
help='Number of parallel tests to run.', help='Number of parallel tests to run.',
) )
p.add_argument( p.add_argument(
'--python3', '--python3',
default=_py3default(), default=_py3default(),
help='python3 interpreter to use for test run', help='python3 interpreter to use for test run',
) )

doc/gendoc.py

msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY) msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY) msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
except ImportError: except ImportError:
pass pass
# This script is executed during installs and may not have C extensions # This script is executed during installs and may not have C extensions
# available. Relax C module requirements. # available. Relax C module requirements.
os.environ[r'HGMODULEPOLICY'] = r'allow' os.environ['HGMODULEPOLICY'] = 'allow'
# import from the live mercurial repo # import from the live mercurial repo
sys.path.insert(0, "..") sys.path.insert(0, "..")
from mercurial import demandimport from mercurial import demandimport
demandimport.enable() demandimport.enable()
# Load util so that the locale path is set by i18n.setdatapath() before # Load util so that the locale path is set by i18n.setdatapath() before
# calling _(). # calling _().
from mercurial import util from mercurial import util

hgdemandimport/demandimportpy2.py

for x in after: for x in after:
subload(mod, x) subload(mod, x)
# Replace references to this proxy instance with the # Replace references to this proxy instance with the
# actual module. # actual module.
if locals: if locals:
if locals.get(head) is self: if locals.get(head) is self:
locals[head] = mod locals[head] = mod
elif locals.get(head + r'mod') is self: elif locals.get(head + 'mod') is self:
locals[head + r'mod'] = mod locals[head + 'mod'] = mod
for modname in modrefs: for modname in modrefs:
modref = sys.modules.get(modname, None) modref = sys.modules.get(modname, None)
if modref and getattr(modref, head, None) is self: if modref and getattr(modref, head, None) is self:
setattr(modref, head, mod) setattr(modref, head, mod)
object.__setattr__(self, "_module", mod) object.__setattr__(self, "_module", mod)

hgext/acl.py

) )
if hooktype == b'pretxnchangegroup' and source not in ui.configlist( if hooktype == b'pretxnchangegroup' and source not in ui.configlist(
b'acl', b'sources' b'acl', b'sources'
): ):
ui.debug(b'acl: changes have source "%s" - skipping\n' % source) ui.debug(b'acl: changes have source "%s" - skipping\n' % source)
return return
user = None user = None
if source == b'serve' and r'url' in kwargs: if source == b'serve' and 'url' in kwargs:
url = kwargs[r'url'].split(b':') url = kwargs['url'].split(b':')
if url[0] == b'remote' and url[1].startswith(b'http'): if url[0] == b'remote' and url[1].startswith(b'http'):
user = urlreq.unquote(url[3]) user = urlreq.unquote(url[3])
if user is None: if user is None:
user = procutil.getuser() user = procutil.getuser()
ui.debug(b'acl: checking access for user "%s"\n' % user) ui.debug(b'acl: checking access for user "%s"\n' % user)
if hooktype == b'prepushkey': if hooktype == b'prepushkey':
_pkhook(ui, repo, hooktype, node, source, user, **kwargs) _pkhook(ui, repo, hooktype, node, source, user, **kwargs)
else: else:
_txnhook(ui, repo, hooktype, node, source, user, **kwargs) _txnhook(ui, repo, hooktype, node, source, user, **kwargs)
def _pkhook(ui, repo, hooktype, node, source, user, **kwargs): def _pkhook(ui, repo, hooktype, node, source, user, **kwargs):
if kwargs[r'namespace'] == b'bookmarks': if kwargs['namespace'] == b'bookmarks':
bookmark = kwargs[r'key'] bookmark = kwargs['key']
ctx = kwargs[r'new'] ctx = kwargs['new']
allowbookmarks = buildmatch(ui, None, user, b'acl.allow.bookmarks') allowbookmarks = buildmatch(ui, None, user, b'acl.allow.bookmarks')
denybookmarks = buildmatch(ui, None, user, b'acl.deny.bookmarks') denybookmarks = buildmatch(ui, None, user, b'acl.deny.bookmarks')
if denybookmarks and denybookmarks(bookmark): if denybookmarks and denybookmarks(bookmark):
raise error.Abort( raise error.Abort(
_( _(
b'acl: user "%s" denied on bookmark "%s"' b'acl: user "%s" denied on bookmark "%s"'
b' (changeset "%s")' b' (changeset "%s")'

hgext/beautifygraph.py

def extsetup(ui): def extsetup(ui):
if ui.plain(b'graph'): if ui.plain(b'graph'):
return return
if encoding.encoding != b'UTF-8': if encoding.encoding != b'UTF-8':
ui.warn(_(b'beautifygraph: unsupported encoding, UTF-8 required\n')) ui.warn(_(b'beautifygraph: unsupported encoding, UTF-8 required\n'))
return return
if r'A' in encoding._wide: if 'A' in encoding._wide:
ui.warn( ui.warn(
_( _(
b'beautifygraph: unsupported terminal settings, ' b'beautifygraph: unsupported terminal settings, '
b'monospace narrow text required\n' b'monospace narrow text required\n'
) )
) )
return return
extensions.wrapfunction(graphmod, b'outputgraph', outputprettygraph) extensions.wrapfunction(graphmod, b'outputgraph', outputprettygraph)
extensions.wrapfunction(templatekw, b'getgraphnode', getprettygraphnode) extensions.wrapfunction(templatekw, b'getgraphnode', getprettygraphnode)

hgext/blackbox.py

) )
def blackbox(ui, repo, *revs, **opts): def blackbox(ui, repo, *revs, **opts):
'''view the recent repository events '''view the recent repository events
''' '''
if not repo.vfs.exists(b'blackbox.log'): if not repo.vfs.exists(b'blackbox.log'):
return return
limit = opts.get(r'limit') limit = opts.get('limit')
fp = repo.vfs(b'blackbox.log', b'r') fp = repo.vfs(b'blackbox.log', b'r')
lines = fp.read().split(b'\n') lines = fp.read().split(b'\n')
count = 0 count = 0
output = [] output = []
for line in reversed(lines): for line in reversed(lines):
if count >= limit: if count >= limit:
break break
# count the commands by matching lines like: 2013/01/23 19:13:36 root> # count the commands by matching lines like: 2013/01/23 19:13:36 root>
if re.match(br'^\d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2} .*> .*', line): if re.match(br'^\d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2} .*> .*', line):
count += 1 count += 1
output.append(line) output.append(line)
ui.status(b'\n'.join(reversed(output))) ui.status(b'\n'.join(reversed(output)))

hgext/bookflow.py

b"'hg up %s'" b"'hg up %s'"
) )
% active % active
) )
return rc return rc
def commands_branch(orig, ui, repo, label=None, **opts): def commands_branch(orig, ui, repo, label=None, **opts):
if label and not opts.get(r'clean') and not opts.get(r'rev'): if label and not opts.get('clean') and not opts.get('rev'):
raise error.Abort( raise error.Abort(
_( _(
b"creating named branches is disabled and you should use bookmarks" b"creating named branches is disabled and you should use bookmarks"
), ),
hint=b"see 'hg help bookflow'", hint=b"see 'hg help bookflow'",
) )
return orig(ui, repo, label, **opts) return orig(ui, repo, label, **opts)

hgext/bugzilla.py

'''update bug state with comment text. '''update bug state with comment text.
Try adding comment as committer of changeset, otherwise as Try adding comment as committer of changeset, otherwise as
default bugzilla user.''' default bugzilla user.'''
if len(newstate) > 0: if len(newstate) > 0:
self.ui.warn(_(b"Bugzilla/MySQL cannot update bug state\n")) self.ui.warn(_(b"Bugzilla/MySQL cannot update bug state\n"))
(user, userid) = self.get_bugzilla_user(committer) (user, userid) = self.get_bugzilla_user(committer)
now = time.strftime(r'%Y-%m-%d %H:%M:%S') now = time.strftime('%Y-%m-%d %H:%M:%S')
self.run( self.run(
'''insert into longdescs '''insert into longdescs
(bug_id, who, bug_when, thetext) (bug_id, who, bug_when, thetext)
values (%s, %s, %s, %s)''', values (%s, %s, %s, %s)''',
(bugid, userid, now, text), (bugid, userid, now, text),
) )
self.run( self.run(
'''insert into bugs_activity (bug_id, who, bug_when, fieldid) '''insert into bugs_activity (bug_id, who, bug_when, fieldid)

hgext/churn.py

a .hgchurn file will be looked for in the working directory root. a .hgchurn file will be looked for in the working directory root.
Aliases will be split from the rightmost "=". Aliases will be split from the rightmost "=".
''' '''
def pad(s, l): def pad(s, l):
return s + b" " * (l - encoding.colwidth(s)) return s + b" " * (l - encoding.colwidth(s))
amap = {} amap = {}
aliases = opts.get(r'aliases') aliases = opts.get('aliases')
if not aliases and os.path.exists(repo.wjoin(b'.hgchurn')): if not aliases and os.path.exists(repo.wjoin(b'.hgchurn')):
aliases = repo.wjoin(b'.hgchurn') aliases = repo.wjoin(b'.hgchurn')
if aliases: if aliases:
for l in open(aliases, b"rb"): for l in open(aliases, b"rb"):
try: try:
alias, actual = l.rsplit(b'=' in l and b'=' or None, 1) alias, actual = l.rsplit(b'=' in l and b'=' or None, 1)
amap[alias.strip()] = actual.strip() amap[alias.strip()] = actual.strip()
except ValueError: except ValueError:
l = l.strip() l = l.strip()
if l: if l:
ui.warn(_(b"skipping malformed alias: %s\n") % l) ui.warn(_(b"skipping malformed alias: %s\n") % l)
continue continue
rate = list(countrate(ui, repo, amap, *pats, **opts).items()) rate = list(countrate(ui, repo, amap, *pats, **opts).items())
if not rate: if not rate:
return return
if opts.get(r'sort'): if opts.get('sort'):
rate.sort() rate.sort()
else: else:
rate.sort(key=lambda x: (-sum(x[1]), x)) rate.sort(key=lambda x: (-sum(x[1]), x))
# Be careful not to have a zero maxcount (issue833) # Be careful not to have a zero maxcount (issue833)
maxcount = float(max(sum(v) for k, v in rate)) or 1.0 maxcount = float(max(sum(v) for k, v in rate)) or 1.0
maxname = max(len(k) for k, v in rate) maxname = max(len(k) for k, v in rate)
ttywidth = ui.termwidth() ttywidth = ui.termwidth()
ui.debug(b"assuming %i character terminal\n" % ttywidth) ui.debug(b"assuming %i character terminal\n" % ttywidth)
width = ttywidth - maxname - 2 - 2 - 2 width = ttywidth - maxname - 2 - 2 - 2
if opts.get(r'diffstat'): if opts.get('diffstat'):
width -= 15 width -= 15
def format(name, diffstat): def format(name, diffstat):
added, removed = diffstat added, removed = diffstat
return b"%s %15s %s%s\n" % ( return b"%s %15s %s%s\n" % (
pad(name, maxname), pad(name, maxname),
b'+%d/-%d' % (added, removed), b'+%d/-%d' % (added, removed),
ui.label(b'+' * charnum(added), b'diffstat.inserted'), ui.label(b'+' * charnum(added), b'diffstat.inserted'),

hgext/commitextras.py

def _commit(orig, ui, repo, *pats, **opts): def _commit(orig, ui, repo, *pats, **opts):
if util.safehasattr(repo, 'unfiltered'): if util.safehasattr(repo, 'unfiltered'):
repo = repo.unfiltered() repo = repo.unfiltered()
class repoextra(repo.__class__): class repoextra(repo.__class__):
def commit(self, *innerpats, **inneropts): def commit(self, *innerpats, **inneropts):
extras = opts.get(r'extra') extras = opts.get('extra')
for raw in extras: for raw in extras:
if b'=' not in raw: if b'=' not in raw:
msg = _( msg = _(
b"unable to parse '%s', should follow " b"unable to parse '%s', should follow "
b"KEY=VALUE format" b"KEY=VALUE format"
) )
raise error.Abort(msg % raw) raise error.Abort(msg % raw)
k, v = raw.split(b'=', 1) k, v = raw.split(b'=', 1)
if not k: if not k:
msg = _(b"unable to parse '%s', keys can't be empty") msg = _(b"unable to parse '%s', keys can't be empty")
raise error.Abort(msg % raw) raise error.Abort(msg % raw)
if re.search(br'[^\w-]', k): if re.search(br'[^\w-]', k):
msg = _( msg = _(
b"keys can only contain ascii letters, digits," b"keys can only contain ascii letters, digits,"
b" '_' and '-'" b" '_' and '-'"
) )
raise error.Abort(msg) raise error.Abort(msg)
if k in usedinternally: if k in usedinternally:
msg = _( msg = _(
b"key '%s' is used internally, can't be set " b"key '%s' is used internally, can't be set "
b"manually" b"manually"
) )
raise error.Abort(msg % k) raise error.Abort(msg % k)
inneropts[r'extra'][k] = v inneropts['extra'][k] = v
return super(repoextra, self).commit(*innerpats, **inneropts) return super(repoextra, self).commit(*innerpats, **inneropts)
repo.__class__ = repoextra repo.__class__ = repoextra
return orig(ui, repo, *pats, **opts) return orig(ui, repo, *pats, **opts)

hgext/convert/common.py

@property @property
def lineno(self): def lineno(self):
return self._l.lineno return self._l.lineno
def shlexer(data=None, filepath=None, wordchars=None, whitespace=None): def shlexer(data=None, filepath=None, wordchars=None, whitespace=None):
if data is None: if data is None:
if pycompat.ispy3: if pycompat.ispy3:
data = open(filepath, b'r', encoding=r'latin1') data = open(filepath, b'r', encoding='latin1')
else: else:
data = open(filepath, b'r') data = open(filepath, b'r')
else: else:
if filepath is not None: if filepath is not None:
raise error.ProgrammingError( raise error.ProgrammingError(
b'shlexer only accepts data or filepath, not both' b'shlexer only accepts data or filepath, not both'
) )
if pycompat.ispy3: if pycompat.ispy3:

hgext/convert/gnuarch.py

return path return path
def _parsecatlog(self, data, rev): def _parsecatlog(self, data, rev):
try: try:
catlog = mail.parsebytes(data) catlog = mail.parsebytes(data)
# Commit date # Commit date
self.changes[rev].date = dateutil.datestr( self.changes[rev].date = dateutil.datestr(
dateutil.strdate(catlog[r'Standard-date'], b'%Y-%m-%d %H:%M:%S') dateutil.strdate(catlog['Standard-date'], b'%Y-%m-%d %H:%M:%S')
) )
# Commit author # Commit author
self.changes[rev].author = self.recode(catlog[r'Creator']) self.changes[rev].author = self.recode(catlog['Creator'])
# Commit description # Commit description
self.changes[rev].summary = b'\n\n'.join( self.changes[rev].summary = b'\n\n'.join(
( (
self.recode(catlog[r'Summary']), self.recode(catlog['Summary']),
self.recode(catlog.get_payload()), self.recode(catlog.get_payload()),
) )
) )
self.changes[rev].summary = self.recode(self.changes[rev].summary) self.changes[rev].summary = self.recode(self.changes[rev].summary)
# Commit revision origin when dealing with a branch or tag # Commit revision origin when dealing with a branch or tag
if r'Continuation-of' in catlog: if 'Continuation-of' in catlog:
self.changes[rev].continuationof = self.recode( self.changes[rev].continuationof = self.recode(
catlog[r'Continuation-of'] catlog['Continuation-of']
) )
except Exception: except Exception:
raise error.Abort(_(b'could not parse cat-log of %s') % rev) raise error.Abort(_(b'could not parse cat-log of %s') % rev)
def _parsechangeset(self, data, rev): def _parsechangeset(self, data, rev):
for l in data: for l in data:
l = l.strip() l = l.strip()
# Added file (ignore added directory) # Added file (ignore added directory)

hgext/convert/monotone.py

def mtnrun(self, *args, **kwargs): def mtnrun(self, *args, **kwargs):
if self.automatestdio: if self.automatestdio:
return self.mtnrunstdio(*args, **kwargs) return self.mtnrunstdio(*args, **kwargs)
else: else:
return self.mtnrunsingle(*args, **kwargs) return self.mtnrunsingle(*args, **kwargs)
def mtnrunsingle(self, *args, **kwargs): def mtnrunsingle(self, *args, **kwargs):
kwargs[r'd'] = self.path kwargs['d'] = self.path
return self.run0(b'automate', *args, **kwargs) return self.run0(b'automate', *args, **kwargs)
def mtnrunstdio(self, *args, **kwargs): def mtnrunstdio(self, *args, **kwargs):
# Prepare the command in automate stdio format # Prepare the command in automate stdio format
kwargs = pycompat.byteskwargs(kwargs) kwargs = pycompat.byteskwargs(kwargs)
command = [] command = []
for k, v in pycompat.iteritems(kwargs): for k, v in pycompat.iteritems(kwargs):
command.append(b"%d:%s" % (len(k), k)) command.append(b"%d:%s" % (len(k), k))

hgext/convert/subversion.py

@propertycache @propertycache
def manifest(self): def manifest(self):
# As of svn 1.7, the "add" command fails when receiving # As of svn 1.7, the "add" command fails when receiving
# already tracked entries, so we have to track and filter them # already tracked entries, so we have to track and filter them
# ourselves. # ourselves.
m = set() m = set()
output = self.run0(b'ls', recursive=True, xml=True) output = self.run0(b'ls', recursive=True, xml=True)
doc = xml.dom.minidom.parseString(output) doc = xml.dom.minidom.parseString(output)
for e in doc.getElementsByTagName(r'entry'): for e in doc.getElementsByTagName('entry'):
for n in e.childNodes: for n in e.childNodes:
if n.nodeType != n.ELEMENT_NODE or n.tagName != r'name': if n.nodeType != n.ELEMENT_NODE or n.tagName != 'name':
continue continue
name = r''.join( name = ''.join(
c.data for c in n.childNodes if c.nodeType == c.TEXT_NODE c.data for c in n.childNodes if c.nodeType == c.TEXT_NODE
) )
# Entries are compared with names coming from # Entries are compared with names coming from
# mercurial, so bytes with undefined encoding. Our # mercurial, so bytes with undefined encoding. Our
# best bet is to assume they are in local # best bet is to assume they are in local
# encoding. They will be passed to command line calls # encoding. They will be passed to command line calls
# later anyway, so they better be. # later anyway, so they better be.
m.add(encoding.unitolocal(name)) m.add(encoding.unitolocal(name))
if self.delexec: if self.delexec:
self.xargs(self.delexec, b'propdel', b'svn:executable') self.xargs(self.delexec, b'propdel', b'svn:executable')
self.delexec = [] self.delexec = []
if self.setexec: if self.setexec:
self.xargs(self.setexec, b'propset', b'svn:executable', b'*') self.xargs(self.setexec, b'propset', b'svn:executable', b'*')
self.setexec = [] self.setexec = []
fd, messagefile = pycompat.mkstemp(prefix=b'hg-convert-') fd, messagefile = pycompat.mkstemp(prefix=b'hg-convert-')
fp = os.fdopen(fd, r'wb') fp = os.fdopen(fd, 'wb')
fp.write(util.tonativeeol(commit.desc)) fp.write(util.tonativeeol(commit.desc))
fp.close() fp.close()
try: try:
output = self.run0( output = self.run0(
b'commit', b'commit',
username=stringutil.shortuser(commit.author), username=stringutil.shortuser(commit.author),
file=messagefile, file=messagefile,
encoding=b'utf-8', encoding=b'utf-8',

hgext/extdiff.py

to its parent. to its parent.
""" """
def __init__(self, path, cmdline, isgui): def __init__(self, path, cmdline, isgui):
# We can't pass non-ASCII through docstrings (and path is # We can't pass non-ASCII through docstrings (and path is
# in an unknown encoding anyway), but avoid double separators on # in an unknown encoding anyway), but avoid double separators on
# Windows # Windows
docpath = stringutil.escapestr(path).replace(b'\\\\', b'\\') docpath = stringutil.escapestr(path).replace(b'\\\\', b'\\')
self.__doc__ %= {r'path': pycompat.sysstr(stringutil.uirepr(docpath))} self.__doc__ %= {'path': pycompat.sysstr(stringutil.uirepr(docpath))}
self._cmdline = cmdline self._cmdline = cmdline
self._isgui = isgui self._isgui = isgui
def __call__(self, ui, repo, *pats, **opts): def __call__(self, ui, repo, *pats, **opts):
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
options = b' '.join(map(procutil.shellquote, opts[b'option'])) options = b' '.join(map(procutil.shellquote, opts[b'option']))
if options: if options:
options = b' ' + options options = b' ' + options

hgext/fastannotate/commands.py

ctx = scmutil.revsingle(repo, rev) ctx = scmutil.revsingle(repo, rev)
m = scmutil.match(ctx, pats, opts, badfn=bad) m = scmutil.match(ctx, pats, opts, badfn=bad)
for p in ctx.walk(m): for p in ctx.walk(m):
yield p yield p
fastannotatecommandargs = { fastannotatecommandargs = {
r'options': [ 'options': [
(b'r', b'rev', b'.', _(b'annotate the specified revision'), _(b'REV')), (b'r', b'rev', b'.', _(b'annotate the specified revision'), _(b'REV')),
(b'u', b'user', None, _(b'list the author (long with -v)')), (b'u', b'user', None, _(b'list the author (long with -v)')),
(b'f', b'file', None, _(b'list the filename')), (b'f', b'file', None, _(b'list the filename')),
(b'd', b'date', None, _(b'list the date (short with -q)')), (b'd', b'date', None, _(b'list the date (short with -q)')),
(b'n', b'number', None, _(b'list the revision number (default)')), (b'n', b'number', None, _(b'list the revision number (default)')),
(b'c', b'changeset', None, _(b'list the changeset')), (b'c', b'changeset', None, _(b'list the changeset')),
( (
b'l', b'l',
b'rebuild', b'rebuild',
None, None,
_(b'rebuild cache even if it exists (EXPERIMENTAL)'), _(b'rebuild cache even if it exists (EXPERIMENTAL)'),
), ),
] ]
+ commands.diffwsopts + commands.diffwsopts
+ commands.walkopts + commands.walkopts
+ commands.formatteropts, + commands.formatteropts,
r'synopsis': _(b'[-r REV] [-f] [-a] [-u] [-d] [-n] [-c] [-l] FILE...'), 'synopsis': _(b'[-r REV] [-f] [-a] [-u] [-d] [-n] [-c] [-l] FILE...'),
r'inferrepo': True, 'inferrepo': True,
} }
def fastannotate(ui, repo, *pats, **opts): def fastannotate(ui, repo, *pats, **opts):
"""show changeset information by line for each file """show changeset information by line for each file
List changes in files, showing the revision id responsible for each line. List changes in files, showing the revision id responsible for each line.
formatter.write(result, lines, existinglines=existinglines) formatter.write(result, lines, existinglines=existinglines)
formatter.end() formatter.end()
_newopts = set() _newopts = set()
_knownopts = { _knownopts = {
opt[1].replace(b'-', b'_') opt[1].replace(b'-', b'_')
for opt in (fastannotatecommandargs[r'options'] + commands.globalopts) for opt in (fastannotatecommandargs['options'] + commands.globalopts)
} }
def _annotatewrapper(orig, ui, repo, *pats, **opts): def _annotatewrapper(orig, ui, repo, *pats, **opts):
"""used by wrapdefault""" """used by wrapdefault"""
# we need this hack until the obsstore has 0.0 seconds perf impact # we need this hack until the obsstore has 0.0 seconds perf impact
if ui.configbool(b'fastannotate', b'unfilteredrepo'): if ui.configbool(b'fastannotate', b'unfilteredrepo'):
repo = repo.unfiltered() repo = repo.unfiltered()
# treat the file as text (skip the isbinary check) # treat the file as text (skip the isbinary check)
if ui.configbool(b'fastannotate', b'forcetext'): if ui.configbool(b'fastannotate', b'forcetext'):
opts[r'text'] = True opts['text'] = True
# check if we need to do prefetch (client-side) # check if we need to do prefetch (client-side)
rev = opts.get(r'rev') rev = opts.get('rev')
if util.safehasattr(repo, 'prefetchfastannotate') and rev is not None: if util.safehasattr(repo, 'prefetchfastannotate') and rev is not None:
paths = list(_matchpaths(repo, rev, pats, pycompat.byteskwargs(opts))) paths = list(_matchpaths(repo, rev, pats, pycompat.byteskwargs(opts)))
repo.prefetchfastannotate(paths) repo.prefetchfastannotate(paths)
return orig(ui, repo, *pats, **opts) return orig(ui, repo, *pats, **opts)
def registercommand(): def registercommand():

hgext/githelp.py

args = list(args) args = list(args)
while True: while True:
try: try:
args = fancyopts.fancyopts(list(args), cmdoptions, opts, True) args = fancyopts.fancyopts(list(args), cmdoptions, opts, True)
break break
except getopt.GetoptError as ex: except getopt.GetoptError as ex:
if "requires argument" in ex.msg: if "requires argument" in ex.msg:
raise raise
if (r'--' + ex.opt) in ex.msg: if ('--' + ex.opt) in ex.msg:
flag = b'--' + pycompat.bytestr(ex.opt) flag = b'--' + pycompat.bytestr(ex.opt)
elif (r'-' + ex.opt) in ex.msg: elif ('-' + ex.opt) in ex.msg:
flag = b'-' + pycompat.bytestr(ex.opt) flag = b'-' + pycompat.bytestr(ex.opt)
else: else:
raise error.Abort( raise error.Abort(
_(b"unknown option %s") % pycompat.bytestr(ex.opt) _(b"unknown option %s") % pycompat.bytestr(ex.opt)
) )
try: try:
args.remove(flag) args.remove(flag)
except Exception: except Exception:

hgext/gpg.py

return procutil.filter(data, gpgcmd) return procutil.filter(data, gpgcmd)
def verify(self, data, sig): def verify(self, data, sig):
""" returns of the good and bad signatures""" """ returns of the good and bad signatures"""
sigfile = datafile = None sigfile = datafile = None
try: try:
# create temporary files # create temporary files
fd, sigfile = pycompat.mkstemp(prefix=b"hg-gpg-", suffix=b".sig") fd, sigfile = pycompat.mkstemp(prefix=b"hg-gpg-", suffix=b".sig")
fp = os.fdopen(fd, r'wb') fp = os.fdopen(fd, 'wb')
fp.write(sig) fp.write(sig)
fp.close() fp.close()
fd, datafile = pycompat.mkstemp(prefix=b"hg-gpg-", suffix=b".txt") fd, datafile = pycompat.mkstemp(prefix=b"hg-gpg-", suffix=b".txt")
fp = os.fdopen(fd, r'wb') fp = os.fdopen(fd, 'wb')
fp.write(data) fp.write(data)
fp.close() fp.close()
gpgcmd = ( gpgcmd = (
b"%s --logger-fd 1 --status-fd 1 --verify \"%s\" \"%s\"" b"%s --logger-fd 1 --status-fd 1 --verify \"%s\" \"%s\""
% (self.path, sigfile, datafile,) % (self.path, sigfile, datafile,)
) )
ret = procutil.filter(b"", gpgcmd) ret = procutil.filter(b"", gpgcmd)
finally: finally:
if key is not None: if key is not None:
keys.append(key + [fingerprint]) keys.append(key + [fingerprint])
return keys return keys
def newgpg(ui, **opts): def newgpg(ui, **opts):
"""create a new gpg instance""" """create a new gpg instance"""
gpgpath = ui.config(b"gpg", b"cmd") gpgpath = ui.config(b"gpg", b"cmd")
gpgkey = opts.get(r'key') gpgkey = opts.get('key')
if not gpgkey: if not gpgkey:
gpgkey = ui.config(b"gpg", b"key") gpgkey = ui.config(b"gpg", b"key")
return gpg(gpgpath, gpgkey) return gpg(gpgpath, gpgkey)
def sigwalk(repo): def sigwalk(repo):
""" """
walk over every sigs, yields a couple walk over every sigs, yields a couple

hgext/graphlog.py

Print a revision history alongside a revision graph drawn with Print a revision history alongside a revision graph drawn with
ASCII characters. ASCII characters.
Nodes printed as an @ character are parents of the working Nodes printed as an @ character are parents of the working
directory. directory.
This is an alias to :hg:`log -G`. This is an alias to :hg:`log -G`.
""" """
opts[r'graph'] = True opts['graph'] = True
return commands.log(ui, repo, *pats, **opts) return commands.log(ui, repo, *pats, **opts)

hgext/hgk.py

ui.writenoi18n( ui.writenoi18n(
b":100664 000000 %s %s D\t%s\t%s\n" b":100664 000000 %s %s D\t%s\t%s\n"
% (short(mmap[f]), empty, f, f) % (short(mmap[f]), empty, f, f)
) )
## ##
while True: while True:
if opts[r'stdin']: if opts['stdin']:
line = ui.fin.readline() line = ui.fin.readline()
if not line: if not line:
break break
line = line.rstrip(pycompat.oslinesep).split(b' ') line = line.rstrip(pycompat.oslinesep).split(b' ')
node1 = line[0] node1 = line[0]
if len(line) > 1: if len(line) > 1:
node2 = line[1] node2 = line[1]
else: else:
node2 = None node2 = None
node1 = repo.lookup(node1) node1 = repo.lookup(node1)
if node2: if node2:
node2 = repo.lookup(node2) node2 = repo.lookup(node2)
else: else:
node2 = node1 node2 = node1
node1 = repo.changelog.parents(node1)[0] node1 = repo.changelog.parents(node1)[0]
if opts[r'patch']: if opts['patch']:
if opts[r'pretty']: if opts['pretty']:
catcommit(ui, repo, node2, b"") catcommit(ui, repo, node2, b"")
m = scmutil.match(repo[node1], files) m = scmutil.match(repo[node1], files)
diffopts = patch.difffeatureopts(ui) diffopts = patch.difffeatureopts(ui)
diffopts.git = True diffopts.git = True
chunks = patch.diff(repo, node1, node2, match=m, opts=diffopts) chunks = patch.diff(repo, node1, node2, match=m, opts=diffopts)
for chunk in chunks: for chunk in chunks:
ui.write(chunk) ui.write(chunk)
else: else:
__difftree(repo, node1, node2, files=files) __difftree(repo, node1, node2, files=files)
if not opts[r'stdin']: if not opts['stdin']:
break break
def catcommit(ui, repo, n, prefix, ctx=None): def catcommit(ui, repo, n, prefix, ctx=None):
nlprefix = b'\n' + prefix nlprefix = b'\n' + prefix
if ctx is None: if ctx is None:
ctx = repo[n] ctx = repo[n]
# use ctx.node() instead ?? # use ctx.node() instead ??
) )
def catfile(ui, repo, type=None, r=None, **opts): def catfile(ui, repo, type=None, r=None, **opts):
"""cat a specific revision""" """cat a specific revision"""
# in stdin mode, every line except the commit is prefixed with two # in stdin mode, every line except the commit is prefixed with two
# spaces. This way the our caller can find the commit without magic # spaces. This way the our caller can find the commit without magic
# strings # strings
# #
prefix = b"" prefix = b""
if opts[r'stdin']: if opts['stdin']:
line = ui.fin.readline() line = ui.fin.readline()
if not line: if not line:
return return
(type, r) = line.rstrip(pycompat.oslinesep).split(b' ') (type, r) = line.rstrip(pycompat.oslinesep).split(b' ')
prefix = b" " prefix = b" "
else: else:
if not type or not r: if not type or not r:
ui.warn(_(b"cat-file: type or revision not supplied\n")) ui.warn(_(b"cat-file: type or revision not supplied\n"))
commands.help_(ui, b'cat-file') commands.help_(ui, b'cat-file')
while r: while r:
if type != b"commit": if type != b"commit":
ui.warn(_(b"aborting hg cat-file only understands commits\n")) ui.warn(_(b"aborting hg cat-file only understands commits\n"))
return 1 return 1
n = repo.lookup(r) n = repo.lookup(r)
catcommit(ui, repo, n, prefix) catcommit(ui, repo, n, prefix)
if opts[r'stdin']: if opts['stdin']:
line = ui.fin.readline() line = ui.fin.readline()
if not line: if not line:
break break
(type, r) = line.rstrip(pycompat.oslinesep).split(b' ') (type, r) = line.rstrip(pycompat.oslinesep).split(b' ')
else: else:
break break
) )
def revlist(ui, repo, *revs, **opts): def revlist(ui, repo, *revs, **opts):
"""print revisions""" """print revisions"""
if opts[b'header']: if opts[b'header']:
full = b"commit" full = b"commit"
else: else:
full = None full = None
copy = [x for x in revs] copy = [x for x in revs]
revtree(ui, copy, repo, full, opts[r'max_count'], opts[r'parents']) revtree(ui, copy, repo, full, opts['max_count'], opts[r'parents'])
@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,
) )

hgext/histedit.py

Note that fold has its own separated logic because its handling is a bit Note that fold has its own separated logic because its handling is a bit
different and not easily factored out of the fold method. different and not easily factored out of the fold method.
""" """
phasemin = src.phase() phasemin = src.phase()
def commitfunc(**kwargs): def commitfunc(**kwargs):
overrides = {(b'phases', b'new-commit'): phasemin} overrides = {(b'phases', b'new-commit'): phasemin}
with repo.ui.configoverride(overrides, b'histedit'): with repo.ui.configoverride(overrides, b'histedit'):
extra = kwargs.get(r'extra', {}).copy() extra = kwargs.get('extra', {}).copy()
extra[b'histedit_source'] = src.hex() extra[b'histedit_source'] = src.hex()
kwargs[r'extra'] = extra kwargs['extra'] = extra
return repo.commit(**kwargs) return repo.commit(**kwargs)
return commitfunc return commitfunc
def applychanges(ui, repo, ctx, opts): def applychanges(ui, repo, ctx, opts):
"""Merge changeset from ctx (only) in the current working directory""" """Merge changeset from ctx (only) in the current working directory"""
wcpar = repo.dirstate.p1() wcpar = repo.dirstate.p1()
) )
ctxs = [] ctxs = []
for i, r in enumerate(revs): for i, r in enumerate(revs):
ctxs.append(histeditrule(repo[r], i)) ctxs.append(histeditrule(repo[r], i))
# Curses requires setting the locale or it will default to the C # Curses requires setting the locale or it will default to the C
# locale. This sets the locale to the user's default system # locale. This sets the locale to the user's default system
# locale. # locale.
locale.setlocale(locale.LC_ALL, r'') locale.setlocale(locale.LC_ALL, '')
rc = curses.wrapper(functools.partial(_chisteditmain, repo, ctxs)) rc = curses.wrapper(functools.partial(_chisteditmain, repo, ctxs))
curses.echo() curses.echo()
curses.endwin() curses.endwin()
if rc is False: if rc is False:
ui.write(_(b"histedit aborted\n")) ui.write(_(b"histedit aborted\n"))
return 0 return 0
if type(rc) is list: if type(rc) is list:
ui.status(_(b"performing changes\n")) ui.status(_(b"performing changes\n"))

hgext/infinitepush/__init__.py

experimental = b'experimental' experimental = b'experimental'
configbookmark = b'server-bundlestore-bookmark' configbookmark = b'server-bundlestore-bookmark'
configscratchpush = b'infinitepush-scratchpush' configscratchpush = b'infinitepush-scratchpush'
scratchbranchparttype = bundleparts.scratchbranchparttype scratchbranchparttype = bundleparts.scratchbranchparttype
revsetpredicate = registrar.revsetpredicate() revsetpredicate = registrar.revsetpredicate()
templatekeyword = registrar.templatekeyword() templatekeyword = registrar.templatekeyword()
_scratchbranchmatcher = lambda x: False _scratchbranchmatcher = lambda x: False
_maybehash = re.compile(r'^[a-f0-9]+$').search _maybehash = re.compile('^[a-f0-9]+$').search
def _buildexternalbundlestore(ui): def _buildexternalbundlestore(ui):
put_args = ui.configlist(b'infinitepush', b'put_args', []) put_args = ui.configlist(b'infinitepush', b'put_args', [])
put_binary = ui.config(b'infinitepush', b'put_binary') put_binary = ui.config(b'infinitepush', b'put_binary')
if not put_binary: if not put_binary:
raise error.Abort(b'put binary is not specified') raise error.Abort(b'put binary is not specified')
get_args = ui.configlist(b'infinitepush', b'get_args', []) get_args = ui.configlist(b'infinitepush', b'get_args', [])
if bundlepart: if bundlepart:
bundler.addpart(bundlepart) bundler.addpart(bundlepart)
# storing the bundle in the bundlestore # storing the bundle in the bundlestore
buf = util.chunkbuffer(bundler.getchunks()) buf = util.chunkbuffer(bundler.getchunks())
fd, bundlefile = pycompat.mkstemp() fd, bundlefile = pycompat.mkstemp()
try: try:
try: try:
fp = os.fdopen(fd, r'wb') fp = os.fdopen(fd, 'wb')
fp.write(buf.read()) fp.write(buf.read())
finally: finally:
fp.close() fp.close()
storebundle(op, {}, bundlefile) storebundle(op, {}, bundlefile)
finally: finally:
try: try:
os.unlink(bundlefile) os.unlink(bundlefile)
except Exception: except Exception:
bundler.addpart(bundlepart) bundler.addpart(bundlepart)
# If commits were sent, store them # If commits were sent, store them
if cgparams: if cgparams:
buf = util.chunkbuffer(bundler.getchunks()) buf = util.chunkbuffer(bundler.getchunks())
fd, bundlefile = pycompat.mkstemp() fd, bundlefile = pycompat.mkstemp()
try: try:
try: try:
fp = os.fdopen(fd, r'wb') fp = os.fdopen(fd, 'wb')
fp.write(buf.read()) fp.write(buf.read())
finally: finally:
fp.close() fp.close()
storebundle(op, cgparams, bundlefile) storebundle(op, cgparams, bundlefile)
finally: finally:
try: try:
os.unlink(bundlefile) os.unlink(bundlefile)
except Exception: except Exception:
cgpart = bundle2.bundlepart(b'changegroup', data=part.read()) cgpart = bundle2.bundlepart(b'changegroup', data=part.read())
cgpart.addparam(b'version', cgversion) cgpart.addparam(b'version', cgversion)
bundler.addpart(cgpart) bundler.addpart(cgpart)
buf = util.chunkbuffer(bundler.getchunks()) buf = util.chunkbuffer(bundler.getchunks())
fd, bundlefile = pycompat.mkstemp() fd, bundlefile = pycompat.mkstemp()
try: try:
try: try:
fp = os.fdopen(fd, r'wb') fp = os.fdopen(fd, 'wb')
fp.write(buf.read()) fp.write(buf.read())
finally: finally:
fp.close() fp.close()
storebundle(op, part.params, bundlefile) storebundle(op, part.params, bundlefile)
finally: finally:
try: try:
os.unlink(bundlefile) os.unlink(bundlefile)
except OSError as e: except OSError as e:

hgext/infinitepush/common.py

return _makebundlefromraw(bundleraw) return _makebundlefromraw(bundleraw)
def _makebundlefromraw(data): def _makebundlefromraw(data):
fp = None fp = None
fd, bundlefile = pycompat.mkstemp() fd, bundlefile = pycompat.mkstemp()
try: # guards bundlefile try: # guards bundlefile
try: # guards fp try: # guards fp
fp = os.fdopen(fd, r'wb') fp = os.fdopen(fd, 'wb')
fp.write(data) fp.write(data)
finally: finally:
fp.close() fp.close()
except Exception: except Exception:
try: try:
os.unlink(bundlefile) os.unlink(bundlefile)
except Exception: except Exception:
# we would rather see the original exception # we would rather see the original exception
pass pass
raise raise
return bundlefile return bundlefile

hgext/journal.py

return set() return set()
def _mergeentriesiter(*iterables, **kwargs): def _mergeentriesiter(*iterables, **kwargs):
"""Given a set of sorted iterables, yield the next entry in merged order """Given a set of sorted iterables, yield the next entry in merged order
Note that by default entries go from most recent to oldest. Note that by default entries go from most recent to oldest.
""" """
order = kwargs.pop(r'order', max) order = kwargs.pop('order', max)
iterables = [iter(it) for it in iterables] iterables = [iter(it) for it in iterables]
# this tracks still active iterables; iterables are deleted as they are # this tracks still active iterables; iterables are deleted as they are
# exhausted, which is why this is a dictionary and why each entry also # exhausted, which is why this is a dictionary and why each entry also
# stores the key. Entries are mutable so we can store the next value each # stores the key. Entries are mutable so we can store the next value each
# time. # time.
iterable_map = {} iterable_map = {}
for key, it in enumerate(iterables): for key, it in enumerate(iterables):
try: try:
for entry in _mergeentriesiter(local, shared, order=min): for entry in _mergeentriesiter(local, shared, order=min):
storage._write(repo.vfs, entry) storage._write(repo.vfs, entry)
return orig(ui, repo, repopath) return orig(ui, repo, repopath)
class journalentry( class journalentry(
collections.namedtuple( collections.namedtuple(
r'journalentry', 'journalentry',
r'timestamp user command namespace name oldhashes newhashes', 'timestamp user command namespace name oldhashes newhashes',
) )
): ):
"""Individual journal entry """Individual journal entry
* timestamp: a mercurial (time, timezone) tuple * timestamp: a mercurial (time, timezone) tuple
* user: the username that ran the command * user: the username that ran the command
* namespace: the entry namespace, an opaque string * namespace: the entry namespace, an opaque string
* name: the name of the changed item, opaque string with meaning in the * name: the name of the changed item, opaque string with meaning in the

hgext/keyword.py

baseui = repo.baseui baseui = repo.baseui
repo = localrepo.instance(baseui, tmpdir, create=True) repo = localrepo.instance(baseui, tmpdir, create=True)
ui.setconfig(b'keyword', fn, b'', b'keyword') ui.setconfig(b'keyword', fn, b'', b'keyword')
svn = ui.configbool(b'keywordset', b'svn') svn = ui.configbool(b'keywordset', b'svn')
# explicitly set keywordset for demo output # explicitly set keywordset for demo output
ui.setconfig(b'keywordset', b'svn', svn, b'keyword') ui.setconfig(b'keywordset', b'svn', svn, b'keyword')
uikwmaps = ui.configitems(b'keywordmaps') uikwmaps = ui.configitems(b'keywordmaps')
if args or opts.get(r'rcfile'): if args or opts.get('rcfile'):
ui.status(_(b'\n\tconfiguration using custom keyword template maps\n')) ui.status(_(b'\n\tconfiguration using custom keyword template maps\n'))
if uikwmaps: if uikwmaps:
ui.status(_(b'\textending current template maps\n')) ui.status(_(b'\textending current template maps\n'))
if opts.get(r'default') or not uikwmaps: if opts.get('default') or not uikwmaps:
if svn: if svn:
ui.status(_(b'\toverriding default svn keywordset\n')) ui.status(_(b'\toverriding default svn keywordset\n'))
else: else:
ui.status(_(b'\toverriding default cvs keywordset\n')) ui.status(_(b'\toverriding default cvs keywordset\n'))
if opts.get(r'rcfile'): if opts.get('rcfile'):
ui.readconfig(opts.get(b'rcfile')) ui.readconfig(opts.get(b'rcfile'))
if args: if args:
# simulate hgrc parsing # simulate hgrc parsing
rcmaps = b'[keywordmaps]\n%s\n' % b'\n'.join(args) rcmaps = b'[keywordmaps]\n%s\n' % b'\n'.join(args)
repo.vfs.write(b'hgrc', rcmaps) repo.vfs.write(b'hgrc', rcmaps)
ui.readconfig(repo.vfs.join(b'hgrc')) ui.readconfig(repo.vfs.join(b'hgrc'))
kwmaps = dict(ui.configitems(b'keywordmaps')) kwmaps = dict(ui.configitems(b'keywordmaps'))
elif opts.get(r'default'): elif opts.get('default'):
if svn: if svn:
ui.status(_(b'\n\tconfiguration using default svn keywordset\n')) ui.status(_(b'\n\tconfiguration using default svn keywordset\n'))
else: else:
ui.status(_(b'\n\tconfiguration using default cvs keywordset\n')) ui.status(_(b'\n\tconfiguration using default cvs keywordset\n'))
kwmaps = _defaultkwmaps(ui) kwmaps = _defaultkwmaps(ui)
if uikwmaps: if uikwmaps:
ui.status(_(b'\tdisabling current template maps\n')) ui.status(_(b'\tdisabling current template maps\n'))
for k, v in pycompat.iteritems(kwmaps): for k, v in pycompat.iteritems(kwmaps):

hgext/largefiles/lfcommands.py

hg lfpull -r "head() and not closed()" hg lfpull -r "head() and not closed()"
- pull largefiles on the default branch:: - pull largefiles on the default branch::
hg lfpull -r "branch(default)" hg lfpull -r "branch(default)"
""" """
repo.lfpullsource = source repo.lfpullsource = source
revs = opts.get(r'rev', []) revs = opts.get('rev', [])
if not revs: if not revs:
raise error.Abort(_(b'no revisions specified')) raise error.Abort(_(b'no revisions specified'))
revs = scmutil.revrange(repo, revs) revs = scmutil.revrange(repo, revs)
numcached = 0 numcached = 0
for rev in revs: for rev in revs:
ui.note(_(b'pulling largefiles for revision %d\n') % rev) ui.note(_(b'pulling largefiles for revision %d\n') % rev)
(cached, missing) = cachelfiles(ui, repo, rev) (cached, missing) = cachelfiles(ui, repo, rev)

hgext/largefiles/overrides.py

m._fileset = set(m._files) m._fileset = set(m._files)
m.always = lambda: False m.always = lambda: False
origmatchfn = m.matchfn origmatchfn = m.matchfn
m.matchfn = lambda f: notlfile(f) and origmatchfn(f) m.matchfn = lambda f: notlfile(f) and origmatchfn(f)
return m return m
def addlargefiles(ui, repo, isaddremove, matcher, uipathfn, **opts): def addlargefiles(ui, repo, isaddremove, matcher, uipathfn, **opts):
large = opts.get(r'large') large = opts.get('large')
lfsize = lfutil.getminsize( lfsize = lfutil.getminsize(
ui, lfutil.islfilesrepo(repo), opts.get(r'lfsize') ui, lfutil.islfilesrepo(repo), opts.get('lfsize')
) )
lfmatcher = None lfmatcher = None
if lfutil.islfilesrepo(repo): if lfutil.islfilesrepo(repo):
lfpats = ui.configlist(lfutil.longname, b'patterns') lfpats = ui.configlist(lfutil.longname, b'patterns')
if lfpats: if lfpats:
lfmatcher = matchmod.match(repo.root, b'', list(lfpats)) lfmatcher = matchmod.match(repo.root, b'', list(lfpats))
if ui.verbose or not exact: if ui.verbose or not exact:
ui.status(_(b'adding %s as a largefile\n') % uipathfn(f)) ui.status(_(b'adding %s as a largefile\n') % uipathfn(f))
bad = [] bad = []
# Need to lock, otherwise there could be a race condition between # Need to lock, otherwise there could be a race condition between
# when standins are created and added to the repo. # when standins are created and added to the repo.
with repo.wlock(): with repo.wlock():
if not opts.get(r'dry_run'): if not opts.get('dry_run'):
standins = [] standins = []
lfdirstate = lfutil.openlfdirstate(ui, repo) lfdirstate = lfutil.openlfdirstate(ui, repo)
for f in lfnames: for f in lfnames:
standinname = lfutil.standin(f) standinname = lfutil.standin(f)
lfutil.writestandin( lfutil.writestandin(
repo, repo,
standinname, standinname,
hash=b'', hash=b'',
repo.lfstatus = True repo.lfstatus = True
try: try:
yield yield
finally: finally:
repo.lfstatus = oldvalue repo.lfstatus = oldvalue
def removelargefiles(ui, repo, isaddremove, matcher, uipathfn, dryrun, **opts): def removelargefiles(ui, repo, isaddremove, matcher, uipathfn, dryrun, **opts):
after = opts.get(r'after') after = opts.get('after')
m = composelargefilematcher(matcher, repo[None].manifest()) m = composelargefilematcher(matcher, repo[None].manifest())
with lfstatus(repo): with lfstatus(repo):
s = repo.status(match=m, clean=not isaddremove) s = repo.status(match=m, clean=not isaddremove)
manifest = repo[None].manifest() manifest = repo[None].manifest()
modified, added, deleted, clean = [ modified, added, deleted, clean = [
[f for f in list if lfutil.standin(f) in manifest] [f for f in list if lfutil.standin(f) in manifest]
for list in (s.modified, s.added, s.deleted, s.clean) for list in (s.modified, s.added, s.deleted, s.clean)
] ]
_( _(
b'add all files above this size (in megabytes) ' b'add all files above this size (in megabytes) '
b'as largefiles (default: 10)' b'as largefiles (default: 10)'
), ),
), ),
], ],
) )
def overrideadd(orig, ui, repo, *pats, **opts): def overrideadd(orig, ui, repo, *pats, **opts):
if opts.get(r'normal') and opts.get(r'large'): if opts.get('normal') and opts.get('large'):
raise error.Abort(_(b'--normal cannot be used with --large')) raise error.Abort(_(b'--normal cannot be used with --large'))
return orig(ui, repo, *pats, **opts) return orig(ui, repo, *pats, **opts)
@eh.wrapfunction(cmdutil, b'add') @eh.wrapfunction(cmdutil, b'add')
def cmdutiladd(orig, ui, repo, matcher, prefix, uipathfn, explicitonly, **opts): def cmdutiladd(orig, ui, repo, matcher, prefix, uipathfn, explicitonly, **opts):
# The --normal flag short circuits this override # The --normal flag short circuits this override
if opts.get(r'normal'): if opts.get('normal'):
return orig(ui, repo, matcher, prefix, uipathfn, explicitonly, **opts) return orig(ui, repo, matcher, prefix, uipathfn, explicitonly, **opts)
ladded, lbad = addlargefiles(ui, repo, False, matcher, uipathfn, **opts) ladded, lbad = addlargefiles(ui, repo, False, matcher, uipathfn, **opts)
normalmatcher = composenormalfilematcher( normalmatcher = composenormalfilematcher(
matcher, repo[None].manifest(), ladded matcher, repo[None].manifest(), ladded
) )
bad = orig(ui, repo, normalmatcher, prefix, uipathfn, explicitonly, **opts) bad = orig(ui, repo, normalmatcher, prefix, uipathfn, explicitonly, **opts)
b'', b'',
b'lfc', b'lfc',
None, None,
_(b'verify local largefile contents, not just existence'), _(b'verify local largefile contents, not just existence'),
), ),
], ],
) )
def overrideverify(orig, ui, repo, *pats, **opts): def overrideverify(orig, ui, repo, *pats, **opts):
large = opts.pop(r'large', False) large = opts.pop('large', False)
all = opts.pop(r'lfa', False) all = opts.pop('lfa', False)
contents = opts.pop(r'lfc', False) contents = opts.pop('lfc', False)
result = orig(ui, repo, *pats, **opts) result = orig(ui, repo, *pats, **opts)
if large or all or contents: if large or all or contents:
result = result or lfcommands.verifylfiles(ui, repo, all, contents) result = result or lfcommands.verifylfiles(ui, repo, all, contents)
return result return result
@eh.wrapcommand( @eh.wrapcommand(
b'debugstate', b'debugstate',
opts=[(b'', b'large', None, _(b'display largefiles dirstate'))], opts=[(b'', b'large', None, _(b'display largefiles dirstate'))],
) )
def overridedebugstate(orig, ui, repo, *pats, **opts): def overridedebugstate(orig, ui, repo, *pats, **opts):
large = opts.pop(r'large', False) large = opts.pop('large', False)
if large: if large:
class fakerepo(object): class fakerepo(object):
dirstate = lfutil.openlfdirstate(ui, repo) dirstate = lfutil.openlfdirstate(ui, repo)
orig(ui, fakerepo, *pats, **opts) orig(ui, fakerepo, *pats, **opts)
else: else:
orig(ui, repo, *pats, **opts) orig(ui, repo, *pats, **opts)
) )
def overridepull(orig, ui, repo, source=None, **opts): def overridepull(orig, ui, repo, source=None, **opts):
revsprepull = len(repo) revsprepull = len(repo)
if not source: if not source:
source = b'default' source = b'default'
repo.lfpullsource = source repo.lfpullsource = source
result = orig(ui, repo, source, **opts) result = orig(ui, repo, source, **opts)
revspostpull = len(repo) revspostpull = len(repo)
lfrevs = opts.get(r'lfrev', []) lfrevs = opts.get('lfrev', [])
if opts.get(r'all_largefiles'): if opts.get('all_largefiles'):
lfrevs.append(b'pulled()') lfrevs.append(b'pulled()')
if lfrevs and revspostpull > revsprepull: if lfrevs and revspostpull > revsprepull:
numcached = 0 numcached = 0
repo.firstpulled = revsprepull # for pulled() revset expression repo.firstpulled = revsprepull # for pulled() revset expression
try: try:
for rev in scmutil.revrange(repo, lfrevs): for rev in scmutil.revrange(repo, lfrevs):
ui.note(_(b'pulling largefiles for revision %d\n') % rev) ui.note(_(b'pulling largefiles for revision %d\n') % rev)
(cached, missing) = lfcommands.cachelfiles(ui, repo, rev) (cached, missing) = lfcommands.cachelfiles(ui, repo, rev)
[], [],
_(b'upload largefiles for these revisions'), _(b'upload largefiles for these revisions'),
_(b'REV'), _(b'REV'),
) )
], ],
) )
def overridepush(orig, ui, repo, *args, **kwargs): def overridepush(orig, ui, repo, *args, **kwargs):
"""Override push command and store --lfrev parameters in opargs""" """Override push command and store --lfrev parameters in opargs"""
lfrevs = kwargs.pop(r'lfrev', None) lfrevs = kwargs.pop('lfrev', None)
if lfrevs: if lfrevs:
opargs = kwargs.setdefault(r'opargs', {}) opargs = kwargs.setdefault('opargs', {})
opargs[b'lfrevs'] = scmutil.revrange(repo, lfrevs) opargs[b'lfrevs'] = scmutil.revrange(repo, lfrevs)
return orig(ui, repo, *args, **kwargs) return orig(ui, repo, *args, **kwargs)
@eh.wrapfunction(exchange, b'pushoperation') @eh.wrapfunction(exchange, b'pushoperation')
def exchangepushoperation(orig, *args, **kwargs): def exchangepushoperation(orig, *args, **kwargs):
"""Override pushoperation constructor and store lfrevs parameter""" """Override pushoperation constructor and store lfrevs parameter"""
lfrevs = kwargs.pop(r'lfrevs', None) lfrevs = kwargs.pop('lfrevs', None)
pushop = orig(*args, **kwargs) pushop = orig(*args, **kwargs)
pushop.lfrevs = lfrevs pushop.lfrevs = lfrevs
return pushop return pushop
@eh.revsetpredicate(b'pulled()') @eh.revsetpredicate(b'pulled()')
def pulledrevsetsymbol(repo, subset, x): def pulledrevsetsymbol(repo, subset, x):
"""Changesets that just has been pulled. """Changesets that just has been pulled.
_(b'download all versions of all largefiles'), _(b'download all versions of all largefiles'),
) )
], ],
) )
def overrideclone(orig, ui, source, dest=None, **opts): def overrideclone(orig, ui, source, dest=None, **opts):
d = dest d = dest
if d is None: if d is None:
d = hg.defaultdest(source) d = hg.defaultdest(source)
if opts.get(r'all_largefiles') and not hg.islocal(d): if opts.get('all_largefiles') and not hg.islocal(d):
raise error.Abort( raise error.Abort(
_(b'--all-largefiles is incompatible with non-local destination %s') _(b'--all-largefiles is incompatible with non-local destination %s')
% d % d
) )
return orig(ui, source, dest, **opts) return orig(ui, source, dest, **opts)
return result return result
@eh.wrapcommand(b'rebase', extension=b'rebase') @eh.wrapcommand(b'rebase', extension=b'rebase')
def overriderebase(orig, ui, repo, **opts): def overriderebase(orig, ui, repo, **opts):
if not util.safehasattr(repo, b'_largefilesenabled'): if not util.safehasattr(repo, b'_largefilesenabled'):
return orig(ui, repo, **opts) return orig(ui, repo, **opts)
resuming = opts.get(r'continue') resuming = opts.get('continue')
repo._lfcommithooks.append(lfutil.automatedcommithook(resuming)) repo._lfcommithooks.append(lfutil.automatedcommithook(resuming))
repo._lfstatuswriters.append(lambda *msg, **opts: None) repo._lfstatuswriters.append(lambda *msg, **opts: None)
try: try:
return orig(ui, repo, **opts) return orig(ui, repo, **opts)
finally: finally:
repo._lfstatuswriters.pop() repo._lfstatuswriters.pop()
repo._lfcommithooks.pop() repo._lfcommithooks.pop()
for lfile in orphans: for lfile in orphans:
lfdirstate.drop(lfile) lfdirstate.drop(lfile)
lfdirstate.write() lfdirstate.write()
return result return result
@eh.wrapcommand(b'transplant', extension=b'transplant') @eh.wrapcommand(b'transplant', extension=b'transplant')
def overridetransplant(orig, ui, repo, *revs, **opts): def overridetransplant(orig, ui, repo, *revs, **opts):
resuming = opts.get(r'continue') resuming = opts.get('continue')
repo._lfcommithooks.append(lfutil.automatedcommithook(resuming)) repo._lfcommithooks.append(lfutil.automatedcommithook(resuming))
repo._lfstatuswriters.append(lambda *msg, **opts: None) repo._lfstatuswriters.append(lambda *msg, **opts: None)
try: try:
result = orig(ui, repo, *revs, **opts) result = orig(ui, repo, *revs, **opts)
finally: finally:
repo._lfstatuswriters.pop() repo._lfstatuswriters.pop()
repo._lfcommithooks.pop() repo._lfcommithooks.pop()
return result return result
for chunk in util.filechunkiter(fpin): for chunk in util.filechunkiter(fpin):
fp.write(chunk) fp.write(chunk)
err = 0 err = 0
return err return err
@eh.wrapfunction(merge, b'update') @eh.wrapfunction(merge, b'update')
def mergeupdate(orig, repo, node, branchmerge, force, *args, **kwargs): def mergeupdate(orig, repo, node, branchmerge, force, *args, **kwargs):
matcher = kwargs.get(r'matcher', None) matcher = kwargs.get('matcher', None)
# note if this is a partial update # note if this is a partial update
partial = matcher and not matcher.always() partial = matcher and not matcher.always()
with repo.wlock(): with repo.wlock():
# branch | | | # branch | | |
# merge | force | partial | action # merge | force | partial | action
# -------+-------+---------+-------------- # -------+-------+---------+--------------
# x | x | x | linear-merge # x | x | x | linear-merge
# o | x | x | branch-merge # o | x | x | branch-merge
for lfile in oldclean: for lfile in oldclean:
lfdirstate.normallookup(lfile) lfdirstate.normallookup(lfile)
lfdirstate.write() lfdirstate.write()
oldstandins = lfutil.getstandinsstate(repo) oldstandins = lfutil.getstandinsstate(repo)
# Make sure the merge runs on disk, not in-memory. largefiles is not a # Make sure the merge runs on disk, not in-memory. largefiles is not a
# good candidate for in-memory merge (large files, custom dirstate, # good candidate for in-memory merge (large files, custom dirstate,
# matcher usage). # matcher usage).
kwargs[r'wc'] = repo[None] kwargs['wc'] = repo[None]
result = orig(repo, node, branchmerge, force, *args, **kwargs) result = orig(repo, node, branchmerge, force, *args, **kwargs)
newstandins = lfutil.getstandinsstate(repo) newstandins = lfutil.getstandinsstate(repo)
filelist = lfutil.getlfilestoupdate(oldstandins, newstandins) filelist = lfutil.getlfilestoupdate(oldstandins, newstandins)
# to avoid leaving all largefiles as dirty and thus rehash them, mark # to avoid leaving all largefiles as dirty and thus rehash them, mark
# all the ones that didn't change as clean # all the ones that didn't change as clean
for lfile in oldclean.difference(filelist): for lfile in oldclean.difference(filelist):

hgext/largefiles/proto.py

# unfortunately, httprepository._callpush tries to convert its # unfortunately, httprepository._callpush tries to convert its
# input file-like into a bundle before sending it, so we can't use # input file-like into a bundle before sending it, so we can't use
# it ... # it ...
if issubclass(self.__class__, httppeer.httppeer): if issubclass(self.__class__, httppeer.httppeer):
res = self._call( res = self._call(
b'putlfile', b'putlfile',
data=fd, data=fd,
sha=sha, sha=sha,
headers={r'content-type': r'application/mercurial-0.1'}, headers={'content-type': 'application/mercurial-0.1'},
) )
try: try:
d, output = res.split(b'\n', 1) d, output = res.split(b'\n', 1)
for l in output.splitlines(True): for l in output.splitlines(True):
self.ui.warn(_(b'remote: '), l) # assume l ends with \n self.ui.warn(_(b'remote: '), l) # assume l ends with \n
return int(d) return int(d)
except ValueError: except ValueError:
self.ui.warn(_(b'unexpected putlfile response: %r\n') % res) self.ui.warn(_(b'unexpected putlfile response: %r\n') % res)
return orig(repo, proto) return orig(repo, proto)
def sshrepocallstream(self, cmd, **args): def sshrepocallstream(self, cmd, **args):
if cmd == b'heads' and self.capable(b'largefiles'): if cmd == b'heads' and self.capable(b'largefiles'):
cmd = b'lheads' cmd = b'lheads'
if cmd == b'batch' and self.capable(b'largefiles'): if cmd == b'batch' and self.capable(b'largefiles'):
args[r'cmds'] = args[r'cmds'].replace(b'heads ', b'lheads ') args['cmds'] = args[r'cmds'].replace(b'heads ', b'lheads ')
return ssholdcallstream(self, cmd, **args) return ssholdcallstream(self, cmd, **args)
headsre = re.compile(br'(^|;)heads\b') headsre = re.compile(br'(^|;)heads\b')
def httprepocallstream(self, cmd, **args): def httprepocallstream(self, cmd, **args):
if cmd == b'heads' and self.capable(b'largefiles'): if cmd == b'heads' and self.capable(b'largefiles'):
cmd = b'lheads' cmd = b'lheads'
if cmd == b'batch' and self.capable(b'largefiles'): if cmd == b'batch' and self.capable(b'largefiles'):
args[r'cmds'] = headsre.sub(b'lheads', args[r'cmds']) args['cmds'] = headsre.sub(b'lheads', args['cmds'])
return httpoldcallstream(self, cmd, **args) return httpoldcallstream(self, cmd, **args)

hgext/lfs/__init__.py

repo.__class__ = lfsrepo repo.__class__ = lfsrepo
if b'lfs' not in repo.requirements: if b'lfs' not in repo.requirements:
def checkrequireslfs(ui, repo, **kwargs): def checkrequireslfs(ui, repo, **kwargs):
if b'lfs' in repo.requirements: if b'lfs' in repo.requirements:
return 0 return 0
last = kwargs.get(r'node_last') last = kwargs.get('node_last')
_bin = node.bin _bin = node.bin
if last: if last:
s = repo.set(b'%n:%n', _bin(kwargs[r'node']), _bin(last)) s = repo.set(b'%n:%n', _bin(kwargs['node']), _bin(last))
else: else:
s = repo.set(b'%n', _bin(kwargs[r'node'])) s = repo.set(b'%n', _bin(kwargs['node']))
match = repo._storenarrowmatch match = repo._storenarrowmatch
for ctx in s: for ctx in s:
# TODO: is there a way to just walk the files in the commit? # TODO: is there a way to just walk the files in the commit?
if any( if any(
ctx[f].islfs() for f in ctx.files() if f in ctx and match(f) ctx[f].islfs() for f in ctx.files() if f in ctx and match(f)
): ):
repo.requirements.add(b'lfs') repo.requirements.add(b'lfs')
repo.features.add(repository.REPO_FEATURE_LFS) repo.features.add(repository.REPO_FEATURE_LFS)
@eh.command( @eh.command(
b'debuglfsupload', b'debuglfsupload',
[(b'r', b'rev', [], _(b'upload large files introduced by REV'))], [(b'r', b'rev', [], _(b'upload large files introduced by REV'))],
) )
def debuglfsupload(ui, repo, **opts): def debuglfsupload(ui, repo, **opts):
"""upload lfs blobs added by the working copy parent or given revisions""" """upload lfs blobs added by the working copy parent or given revisions"""
revs = opts.get(r'rev', []) revs = opts.get('rev', [])
pointers = wrapper.extractpointers(repo, scmutil.revrange(repo, revs)) pointers = wrapper.extractpointers(repo, scmutil.revrange(repo, revs))
wrapper.uploadblobs(repo, pointers) wrapper.uploadblobs(repo, pointers)

hgext/lfs/blobstore.py

class lfsauthhandler(util.urlreq.basehandler): class lfsauthhandler(util.urlreq.basehandler):
handler_order = 480 # Before HTTPDigestAuthHandler (== 490) handler_order = 480 # Before HTTPDigestAuthHandler (== 490)
def http_error_401(self, req, fp, code, msg, headers): def http_error_401(self, req, fp, code, msg, headers):
"""Enforces that any authentication performed is HTTP Basic """Enforces that any authentication performed is HTTP Basic
Authentication. No authentication is also acceptable. Authentication. No authentication is also acceptable.
""" """
authreq = headers.get(r'www-authenticate', None) authreq = headers.get('www-authenticate', None)
if authreq: if authreq:
scheme = authreq.split()[0] scheme = authreq.split()[0]
if scheme.lower() != r'basic': if scheme.lower() != 'basic':
msg = _(b'the server must support Basic Authentication') msg = _(b'the server must support Basic Authentication')
raise util.urlerr.httperror( raise util.urlerr.httperror(
req.get_full_url(), req.get_full_url(),
code, code,
encoding.strfromlocal(msg), encoding.strfromlocal(msg),
headers, headers,
fp, fp,
) )
def _batchrequest(self, pointers, action): def _batchrequest(self, pointers, action):
"""Get metadata about objects pointed by pointers for given action """Get metadata about objects pointed by pointers for given action
Return decoded JSON object like {'objects': [{'oid': '', 'size': 1}]} Return decoded JSON object like {'objects': [{'oid': '', 'size': 1}]}
See https://github.com/git-lfs/git-lfs/blob/master/docs/api/batch.md See https://github.com/git-lfs/git-lfs/blob/master/docs/api/batch.md
""" """
objects = [ objects = [
{r'oid': pycompat.strurl(p.oid()), r'size': p.size()} {'oid': pycompat.strurl(p.oid()), 'size': p.size()}
for p in pointers for p in pointers
] ]
requestdata = pycompat.bytesurl( requestdata = pycompat.bytesurl(
json.dumps( json.dumps(
{r'objects': objects, r'operation': pycompat.strurl(action),} {'objects': objects, 'operation': pycompat.strurl(action),}
) )
) )
url = b'%s/objects/batch' % self.baseurl url = b'%s/objects/batch' % self.baseurl
batchreq = util.urlreq.request(pycompat.strurl(url), data=requestdata) batchreq = util.urlreq.request(pycompat.strurl(url), data=requestdata)
batchreq.add_header(r'Accept', r'application/vnd.git-lfs+json') batchreq.add_header('Accept', 'application/vnd.git-lfs+json')
batchreq.add_header(r'Content-Type', r'application/vnd.git-lfs+json') batchreq.add_header('Content-Type', 'application/vnd.git-lfs+json')
try: try:
with contextlib.closing(self.urlopener.open(batchreq)) as rsp: with contextlib.closing(self.urlopener.open(batchreq)) as rsp:
rawjson = rsp.read() rawjson = rsp.read()
except util.urlerr.httperror as ex: except util.urlerr.httperror as ex:
hints = { hints = {
400: _( 400: _(
b'check that lfs serving is enabled on %s and "%s" is ' b'check that lfs serving is enabled on %s and "%s" is '
b'supported' b'supported'
) )
if self.ui.debugflag: if self.ui.debugflag:
self.ui.debug(b'Status: %d\n' % rsp.status) self.ui.debug(b'Status: %d\n' % rsp.status)
# lfs-test-server and hg serve return headers in different order # lfs-test-server and hg serve return headers in different order
headers = pycompat.bytestr(rsp.info()).strip() headers = pycompat.bytestr(rsp.info()).strip()
self.ui.debug(b'%s\n' % b'\n'.join(sorted(headers.splitlines()))) self.ui.debug(b'%s\n' % b'\n'.join(sorted(headers.splitlines())))
if r'objects' in response: if 'objects' in response:
response[r'objects'] = sorted( response['objects'] = sorted(
response[r'objects'], key=lambda p: p[r'oid'] response['objects'], key=lambda p: p['oid']
) )
self.ui.debug( self.ui.debug(
b'%s\n' b'%s\n'
% pycompat.bytesurl( % pycompat.bytesurl(
json.dumps( json.dumps(
response, response,
indent=2, indent=2,
separators=(r'', r': '), separators=('', ': '),
sort_keys=True, sort_keys=True,
) )
) )
) )
def encodestr(x): def encodestr(x):
if isinstance(x, pycompat.unicode): if isinstance(x, pycompat.unicode):
return x.encode('utf-8') return x.encode('utf-8')
# If uploading blobs, read data from local blobstore. # If uploading blobs, read data from local blobstore.
if not localstore.verify(oid): if not localstore.verify(oid):
raise error.Abort( raise error.Abort(
_(b'detected corrupt lfs object: %s') % oid, _(b'detected corrupt lfs object: %s') % oid,
hint=_(b'run hg verify'), hint=_(b'run hg verify'),
) )
request.data = filewithprogress(localstore.open(oid), None) request.data = filewithprogress(localstore.open(oid), None)
request.get_method = lambda: r'PUT' request.get_method = lambda: r'PUT'
request.add_header(r'Content-Type', r'application/octet-stream') request.add_header('Content-Type', 'application/octet-stream')
request.add_header(r'Content-Length', len(request.data)) request.add_header('Content-Length', len(request.data))
for k, v in headers: for k, v in headers:
request.add_header(pycompat.strurl(k), pycompat.strurl(v)) request.add_header(pycompat.strurl(k), pycompat.strurl(v))
response = b'' response = b''
try: try:
with contextlib.closing(self.urlopener.open(request)) as req: with contextlib.closing(self.urlopener.open(request)) as req:
ui = self.ui # Shorten debug lines ui = self.ui # Shorten debug lines

hgext/lfs/wireprotolfsserver.py

if req.headers[b'Accept'] != b'application/vnd.git-lfs+json': if req.headers[b'Accept'] != b'application/vnd.git-lfs+json':
_sethttperror(res, HTTP_NOT_ACCEPTABLE) _sethttperror(res, HTTP_NOT_ACCEPTABLE)
return True return True
# XXX: specify an encoding? # XXX: specify an encoding?
lfsreq = pycompat.json_loads(req.bodyfh.read()) lfsreq = pycompat.json_loads(req.bodyfh.read())
# If no transfer handlers are explicitly requested, 'basic' is assumed. # If no transfer handlers are explicitly requested, 'basic' is assumed.
if r'basic' not in lfsreq.get(r'transfers', [r'basic']): if 'basic' not in lfsreq.get('transfers', ['basic']):
_sethttperror( _sethttperror(
res, res,
HTTP_BAD_REQUEST, HTTP_BAD_REQUEST,
b'Only the basic LFS transfer handler is supported', b'Only the basic LFS transfer handler is supported',
) )
return True return True
operation = lfsreq.get(r'operation') operation = lfsreq.get('operation')
operation = pycompat.bytestr(operation) operation = pycompat.bytestr(operation)
if operation not in (b'upload', b'download'): if operation not in (b'upload', b'download'):
_sethttperror( _sethttperror(
res, res,
HTTP_BAD_REQUEST, HTTP_BAD_REQUEST,
b'Unsupported LFS transfer operation: %s' % operation, b'Unsupported LFS transfer operation: %s' % operation,
) )
return True return True
localstore = repo.svfs.lfslocalblobstore localstore = repo.svfs.lfslocalblobstore
objects = [ objects = [
p p
for p in _batchresponseobjects( for p in _batchresponseobjects(
req, lfsreq.get(r'objects', []), operation, localstore req, lfsreq.get('objects', []), operation, localstore
) )
] ]
rsp = { rsp = {
r'transfer': r'basic', 'transfer': 'basic',
r'objects': objects, 'objects': objects,
} }
res.status = hgwebcommon.statusmessage(HTTP_OK) res.status = hgwebcommon.statusmessage(HTTP_OK)
res.headers[b'Content-Type'] = b'application/vnd.git-lfs+json' res.headers[b'Content-Type'] = b'application/vnd.git-lfs+json'
res.setbodybytes(pycompat.bytestr(json.dumps(rsp))) res.setbodybytes(pycompat.bytestr(json.dumps(rsp)))
return True return True
# } # }
# }] # }]
# } # }
# TODO: Sort out the expires_at/expires_in/authenticated keys. # TODO: Sort out the expires_at/expires_in/authenticated keys.
for obj in objects: for obj in objects:
# Convert unicode to ASCII to create a filesystem path # Convert unicode to ASCII to create a filesystem path
soid = obj.get(r'oid') soid = obj.get('oid')
oid = soid.encode(r'ascii') oid = soid.encode('ascii')
rsp = { rsp = {
r'oid': soid, 'oid': soid,
r'size': obj.get(r'size'), # XXX: should this check the local size? 'size': obj.get('size'), # XXX: should this check the local size?
# r'authenticated': True, # 'authenticated': True,
} }
exists = True exists = True
verifies = False verifies = False
# Verify an existing file on the upload request, so that the client is # Verify an existing file on the upload request, so that the client is
# solicited to re-upload if it corrupt locally. Download requests are # solicited to re-upload if it corrupt locally. Download requests are
# also verified, so the error can be flagged in the Batch API response. # also verified, so the error can be flagged in the Batch API response.
# (Maybe we can use this to short circuit the download for `hg verify`, # (Maybe we can use this to short circuit the download for `hg verify`,
# IFF the client can assert that the remote end is an hg server.) # IFF the client can assert that the remote end is an hg server.)
# Otherwise, it's potentially overkill on download, since it is also # Otherwise, it's potentially overkill on download, since it is also
# verified as the file is streamed to the caller. # verified as the file is streamed to the caller.
try: try:
verifies = store.verify(oid) verifies = store.verify(oid)
if verifies and action == b'upload': if verifies and action == b'upload':
# The client will skip this upload, but make sure it remains # The client will skip this upload, but make sure it remains
# available locally. # available locally.
store.linkfromusercache(oid) store.linkfromusercache(oid)
except IOError as inst: except IOError as inst:
if inst.errno != errno.ENOENT: if inst.errno != errno.ENOENT:
_logexception(req) _logexception(req)
rsp[r'error'] = { rsp['error'] = {
r'code': 500, 'code': 500,
r'message': inst.strerror or r'Internal Server Server', 'message': inst.strerror or 'Internal Server Server',
} }
yield rsp yield rsp
continue continue
exists = False exists = False
# Items are always listed for downloads. They are dropped for uploads # Items are always listed for downloads. They are dropped for uploads
# IFF they already exist locally. # IFF they already exist locally.
if action == b'download': if action == b'download':
if not exists: if not exists:
rsp[r'error'] = { rsp['error'] = {
r'code': 404, 'code': 404,
r'message': "The object does not exist", 'message': "The object does not exist",
} }
yield rsp yield rsp
continue continue
elif not verifies: elif not verifies:
rsp[r'error'] = { rsp['error'] = {
r'code': 422, # XXX: is this the right code? 'code': 422, # XXX: is this the right code?
r'message': "The object is corrupt", 'message': "The object is corrupt",
} }
yield rsp yield rsp
continue continue
elif verifies: elif verifies:
yield rsp # Skip 'actions': already uploaded yield rsp # Skip 'actions': already uploaded
continue continue
expiresat = datetime.datetime.now() + datetime.timedelta(minutes=10) expiresat = datetime.datetime.now() + datetime.timedelta(minutes=10)
def _buildheader(): def _buildheader():
# The spec doesn't mention the Accept header here, but avoid # The spec doesn't mention the Accept header here, but avoid
# a gratuitous deviation from lfs-test-server in the test # a gratuitous deviation from lfs-test-server in the test
# output. # output.
hdr = {r'Accept': r'application/vnd.git-lfs'} hdr = {'Accept': 'application/vnd.git-lfs'}
auth = req.headers.get(b'Authorization', b'') auth = req.headers.get(b'Authorization', b'')
if auth.startswith(b'Basic '): if auth.startswith(b'Basic '):
hdr[r'Authorization'] = pycompat.strurl(auth) hdr['Authorization'] = pycompat.strurl(auth)
return hdr return hdr
rsp[r'actions'] = { rsp['actions'] = {
r'%s' '%s'
% pycompat.strurl(action): { % pycompat.strurl(action): {
r'href': pycompat.strurl( 'href': pycompat.strurl(
b'%s%s/.hg/lfs/objects/%s' % (req.baseurl, req.apppath, oid) b'%s%s/.hg/lfs/objects/%s' % (req.baseurl, req.apppath, oid)
), ),
# datetime.isoformat() doesn't include the 'Z' suffix # datetime.isoformat() doesn't include the 'Z' suffix
"expires_at": expiresat.strftime(r'%Y-%m-%dT%H:%M:%SZ'), "expires_at": expiresat.strftime('%Y-%m-%dT%H:%M:%SZ'),
r'header': _buildheader(), 'header': _buildheader(),
} }
} }
yield rsp yield rsp
def _processbasictransfer(repo, req, res, checkperm): def _processbasictransfer(repo, req, res, checkperm):
"""Handle a single file upload (PUT) or download (GET) action for the Basic """Handle a single file upload (PUT) or download (GET) action for the Basic

hgext/mq.py

class AbortNoCleanup(error.Abort): class AbortNoCleanup(error.Abort):
pass pass
class queue(object): class queue(object):
def __init__(self, ui, baseui, path, patchdir=None): def __init__(self, ui, baseui, path, patchdir=None):
self.basepath = path self.basepath = path
try: try:
with open(os.path.join(path, b'patches.queue'), r'rb') as fh: with open(os.path.join(path, b'patches.queue'), 'rb') as fh:
cur = fh.read().rstrip() cur = fh.read().rstrip()
if not cur: if not cur:
curpath = os.path.join(path, b'patches') curpath = os.path.join(path, b'patches')
else: else:
curpath = os.path.join(path, b'patches-' + cur) curpath = os.path.join(path, b'patches-' + cur)
except IOError: except IOError:
curpath = os.path.join(path, b'patches') curpath = os.path.join(path, b'patches')
The queue repository is unversioned by default. If The queue repository is unversioned by default. If
-c/--create-repo is specified, qinit will create a separate nested -c/--create-repo is specified, qinit will create a separate nested
repository for patches (qinit -c may also be run later to convert repository for patches (qinit -c may also be run later to convert
an unversioned patch repository into a versioned one). You can use an unversioned patch repository into a versioned one). You can use
qcommit to commit changes to this queue repository. qcommit to commit changes to this queue repository.
This command is deprecated. Without -c, it's implied by other relevant This command is deprecated. Without -c, it's implied by other relevant
commands. With -c, use :hg:`init --mq` instead.""" commands. With -c, use :hg:`init --mq` instead."""
return qinit(ui, repo, create=opts.get(r'create_repo')) return qinit(ui, repo, create=opts.get('create_repo'))
@command( @command(
b"qclone", b"qclone",
[ [
(b'', b'pull', None, _(b'use pull protocol to copy metadata')), (b'', b'pull', None, _(b'use pull protocol to copy metadata')),
( (
b'U', b'U',
_(b'hg qseries [-ms]'), _(b'hg qseries [-ms]'),
helpcategory=command.CATEGORY_CHANGE_ORGANIZATION, helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
) )
def series(ui, repo, **opts): def series(ui, repo, **opts):
"""print the entire series file """print the entire series file
Returns 0 on success.""" Returns 0 on success."""
repo.mq.qseries( repo.mq.qseries(
repo, missing=opts.get(r'missing'), summary=opts.get(r'summary') repo, missing=opts.get('missing'), summary=opts.get('summary')
) )
return 0 return 0
@command( @command(
b"qtop", b"qtop",
seriesopts, seriesopts,
_(b'hg qtop [-s]'), _(b'hg qtop [-s]'),
t = 0 t = 0
if t: if t:
q.qseries( q.qseries(
repo, repo,
start=t - 1, start=t - 1,
length=1, length=1,
status=b'A', status=b'A',
summary=opts.get(r'summary'), summary=opts.get('summary'),
) )
else: else:
ui.write(_(b"no patches applied\n")) ui.write(_(b"no patches applied\n"))
return 1 return 1
@command( @command(
b"qnext", b"qnext",
seriesopts, seriesopts,
_(b'hg qnext [-s]'), _(b'hg qnext [-s]'),
helpcategory=command.CATEGORY_CHANGE_ORGANIZATION, helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
) )
def next(ui, repo, **opts): def next(ui, repo, **opts):
"""print the name of the next pushable patch """print the name of the next pushable patch
Returns 0 on success.""" Returns 0 on success."""
q = repo.mq q = repo.mq
end = q.seriesend() end = q.seriesend()
if end == len(q.series): if end == len(q.series):
ui.write(_(b"all patches applied\n")) ui.write(_(b"all patches applied\n"))
return 1 return 1
q.qseries(repo, start=end, length=1, summary=opts.get(r'summary')) q.qseries(repo, start=end, length=1, summary=opts.get('summary'))
@command( @command(
b"qprev", b"qprev",
seriesopts, seriesopts,
_(b'hg qprev [-s]'), _(b'hg qprev [-s]'),
helpcategory=command.CATEGORY_CHANGE_ORGANIZATION, helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
) )
def prev(ui, repo, **opts): def prev(ui, repo, **opts):
"""print the name of the preceding applied patch """print the name of the preceding applied patch
Returns 0 on success.""" Returns 0 on success."""
q = repo.mq q = repo.mq
l = len(q.applied) l = len(q.applied)
if l == 1: if l == 1:
ui.write(_(b"only one patch applied\n")) ui.write(_(b"only one patch applied\n"))
return 1 return 1
if not l: if not l:
ui.write(_(b"no patches applied\n")) ui.write(_(b"no patches applied\n"))
return 1 return 1
idx = q.series.index(q.applied[-2].name) idx = q.series.index(q.applied[-2].name)
q.qseries( q.qseries(
repo, start=idx, length=1, status=b'A', summary=opts.get(r'summary') repo, start=idx, length=1, status=b'A', summary=opts.get('summary')
) )
def setupheaderopts(ui, opts): def setupheaderopts(ui, opts):
if not opts.get(b'user') and opts.get(b'currentuser'): if not opts.get(b'user') and opts.get(b'currentuser'):
opts[b'user'] = ui.username() opts[b'user'] = ui.username()
if not opts.get(b'date') and opts.get(b'currentdate'): if not opts.get(b'date') and opts.get(b'currentdate'):
opts[b'date'] = b"%d %d" % dateutil.makedate() opts[b'date'] = b"%d %d" % dateutil.makedate()
if i != len(guards) - 1: if i != len(guards) - 1:
ui.write(b' ') ui.write(b' ')
ui.write(b'\n') ui.write(b'\n')
q = repo.mq q = repo.mq
applied = set(p.name for p in q.applied) applied = set(p.name for p in q.applied)
patch = None patch = None
args = list(args) args = list(args)
if opts.get(r'list'): if opts.get('list'):
if args or opts.get(r'none'): if args or opts.get('none'):
raise error.Abort( raise error.Abort(
_(b'cannot mix -l/--list with options or arguments') _(b'cannot mix -l/--list with options or arguments')
) )
for i in pycompat.xrange(len(q.series)): for i in pycompat.xrange(len(q.series)):
status(i) status(i)
return return
if not args or args[0][0:1] in b'-+': if not args or args[0][0:1] in b'-+':
if not q.applied: if not q.applied:
raise error.Abort(_(b'no patches applied')) raise error.Abort(_(b'no patches applied'))
patch = q.applied[-1].name patch = q.applied[-1].name
if patch is None and args[0][0:1] not in b'-+': if patch is None and args[0][0:1] not in b'-+':
patch = args.pop(0) patch = args.pop(0)
if patch is None: if patch is None:
raise error.Abort(_(b'no patch to work with')) raise error.Abort(_(b'no patch to work with'))
if args or opts.get(r'none'): if args or opts.get('none'):
idx = q.findseries(patch) idx = q.findseries(patch)
if idx is None: if idx is None:
raise error.Abort(_(b'no patch named %s') % patch) raise error.Abort(_(b'no patch named %s') % patch)
q.setguards(idx, args) q.setguards(idx, args)
q.savedirty() q.savedirty()
else: else:
status(q.series.index(q.lookup(patch))) status(q.series.index(q.lookup(patch)))
helpcategory=command.CATEGORY_CHANGE_ORGANIZATION, helpcategory=command.CATEGORY_CHANGE_ORGANIZATION,
) )
def restore(ui, repo, rev, **opts): def restore(ui, repo, rev, **opts):
"""restore the queue state saved by a revision (DEPRECATED) """restore the queue state saved by a revision (DEPRECATED)
This command is deprecated, use :hg:`rebase` instead.""" This command is deprecated, use :hg:`rebase` instead."""
rev = repo.lookup(rev) rev = repo.lookup(rev)
q = repo.mq q = repo.mq
q.restore( q.restore(repo, rev, delete=opts.get('delete'), qupdate=opts.get('update'))
repo, rev, delete=opts.get(r'delete'), qupdate=opts.get(r'update')
)
q.savedirty() q.savedirty()
return 0 return 0
@command( @command(
b"qsave", b"qsave",
[ [
(b'c', b'copy', None, _(b'copy patch directory')), (b'c', b'copy', None, _(b'copy patch directory')),
stack of applied patches. stack of applied patches.
This can be especially useful if your changes have been applied to This can be especially useful if your changes have been applied to
an upstream repository, or if you are about to push your changes an upstream repository, or if you are about to push your changes
to upstream. to upstream.
Returns 0 on success. Returns 0 on success.
""" """
if not opts.get(r'applied') and not revrange: if not opts.get('applied') and not revrange:
raise error.Abort(_(b'no revisions specified')) raise error.Abort(_(b'no revisions specified'))
elif opts.get(r'applied'): elif opts.get('applied'):
revrange = (b'qbase::qtip',) + revrange revrange = (b'qbase::qtip',) + revrange
q = repo.mq q = repo.mq
if not q.applied: if not q.applied:
ui.status(_(b'no patches applied\n')) ui.status(_(b'no patches applied\n'))
return 0 return 0
revs = scmutil.revrange(repo, revrange) revs = scmutil.revrange(repo, revrange)
def reposetup(ui, repo): def reposetup(ui, repo):
class mqrepo(repo.__class__): class mqrepo(repo.__class__):
@localrepo.unfilteredpropertycache @localrepo.unfilteredpropertycache
def mq(self): def mq(self):
return queue(self.ui, self.baseui, self.path) return queue(self.ui, self.baseui, self.path)
def invalidateall(self): def invalidateall(self):
super(mqrepo, self).invalidateall() super(mqrepo, self).invalidateall()
if localrepo.hasunfilteredcache(self, r'mq'): if localrepo.hasunfilteredcache(self, 'mq'):
# recreate mq in case queue path was changed # recreate mq in case queue path was changed
delattr(self.unfiltered(), r'mq') delattr(self.unfiltered(), 'mq')
def abortifwdirpatched(self, errmsg, force=False): def abortifwdirpatched(self, errmsg, force=False):
if self.mq.applied and self.mq.checkapplied and not force: if self.mq.applied and self.mq.checkapplied and not force:
parents = self.dirstate.parents() parents = self.dirstate.parents()
patches = [s.node for s in self.mq.applied] patches = [s.node for s in self.mq.applied]
if any(p in patches for p in parents): if any(p in patches for p in parents):
raise error.Abort(errmsg) raise error.Abort(errmsg)
if repo.local(): if repo.local():
repo.__class__ = mqrepo repo.__class__ = mqrepo
repo._phasedefaults.append(mqphasedefaults) repo._phasedefaults.append(mqphasedefaults)
def mqimport(orig, ui, repo, *args, **kwargs): def mqimport(orig, ui, repo, *args, **kwargs):
if util.safehasattr(repo, b'abortifwdirpatched') and not kwargs.get( if util.safehasattr(repo, b'abortifwdirpatched') and not kwargs.get(
r'no_commit', False 'no_commit', False
): ):
repo.abortifwdirpatched( repo.abortifwdirpatched(
_(b'cannot import over an applied patch'), kwargs.get(r'force') _(b'cannot import over an applied patch'), kwargs.get('force')
) )
return orig(ui, repo, *args, **kwargs) return orig(ui, repo, *args, **kwargs)
def mqinit(orig, ui, *args, **kwargs): def mqinit(orig, ui, *args, **kwargs):
mq = kwargs.pop(r'mq', None) mq = kwargs.pop('mq', None)
if not mq: if not mq:
return orig(ui, *args, **kwargs) return orig(ui, *args, **kwargs)
if args: if args:
repopath = args[0] repopath = args[0]
if not hg.islocal(repopath): if not hg.islocal(repopath):
raise error.Abort( raise error.Abort(
_(b'only a local queue repository may be initialized') _(b'only a local queue repository may be initialized')
) )
else: else:
repopath = cmdutil.findrepo(encoding.getcwd()) repopath = cmdutil.findrepo(encoding.getcwd())
if not repopath: if not repopath:
raise error.Abort( raise error.Abort(
_(b'there is no Mercurial repository here (.hg not found)') _(b'there is no Mercurial repository here (.hg not found)')
) )
repo = hg.repository(ui, repopath) repo = hg.repository(ui, repopath)
return qinit(ui, repo, True) return qinit(ui, repo, True)
def mqcommand(orig, ui, repo, *args, **kwargs): def mqcommand(orig, ui, repo, *args, **kwargs):
"""Add --mq option to operate on patch repository instead of main""" """Add --mq option to operate on patch repository instead of main"""
# some commands do not like getting unknown options # some commands do not like getting unknown options
mq = kwargs.pop(r'mq', None) mq = kwargs.pop('mq', None)
if not mq: if not mq:
return orig(ui, repo, *args, **kwargs) return orig(ui, repo, *args, **kwargs)
q = repo.mq q = repo.mq
r = q.qrepo() r = q.qrepo()
if not r: if not r:
raise error.Abort(_(b'no queue repository')) raise error.Abort(_(b'no queue repository'))

hgext/narrow/narrowbundle2.py

v v
for v in cgversions for v in cgversions
if v in changegroup.supportedoutgoingversions(repo) if v in changegroup.supportedoutgoingversions(repo)
] ]
if not cgversions: if not cgversions:
raise ValueError(_(b'no common changegroup version')) raise ValueError(_(b'no common changegroup version'))
version = max(cgversions) version = max(cgversions)
include = sorted(filter(bool, kwargs.get(r'includepats', []))) include = sorted(filter(bool, kwargs.get('includepats', [])))
exclude = sorted(filter(bool, kwargs.get(r'excludepats', []))) exclude = sorted(filter(bool, kwargs.get('excludepats', [])))
generateellipsesbundle2( generateellipsesbundle2(
bundler, bundler,
repo, repo,
include, include,
exclude, exclude,
version, version,
common, common,
heads, heads,
kwargs.get(r'depth', None), kwargs.get('depth', None),
) )
def generateellipsesbundle2( def generateellipsesbundle2(
bundler, repo, include, exclude, version, common, heads, depth, bundler, repo, include, exclude, version, common, heads, depth,
): ):
match = narrowspec.match(repo.root, include=include, exclude=exclude) match = narrowspec.match(repo.root, include=include, exclude=exclude)
if depth is not None: if depth is not None:
# Extend changegroup serving to handle requests from narrow clients. # Extend changegroup serving to handle requests from narrow clients.
origcgfn = exchange.getbundle2partsmapping[b'changegroup'] origcgfn = exchange.getbundle2partsmapping[b'changegroup']
def wrappedcgfn(*args, **kwargs): def wrappedcgfn(*args, **kwargs):
repo = args[1] repo = args[1]
if repo.ui.has_section(_NARROWACL_SECTION): if repo.ui.has_section(_NARROWACL_SECTION):
kwargs = exchange.applynarrowacl(repo, kwargs) kwargs = exchange.applynarrowacl(repo, kwargs)
if kwargs.get(r'narrow', False) and repo.ui.configbool( if kwargs.get('narrow', False) and repo.ui.configbool(
b'experimental', b'narrowservebrokenellipses' b'experimental', b'narrowservebrokenellipses'
): ):
getbundlechangegrouppart_narrow(*args, **kwargs) getbundlechangegrouppart_narrow(*args, **kwargs)
else: else:
origcgfn(*args, **kwargs) origcgfn(*args, **kwargs)
exchange.getbundle2partsmapping[b'changegroup'] = wrappedcgfn exchange.getbundle2partsmapping[b'changegroup'] = wrappedcgfn

hgext/narrow/narrowcommands.py

def pullnarrowcmd(orig, ui, repo, *args, **opts): def pullnarrowcmd(orig, ui, repo, *args, **opts):
"""Wraps pull command to allow modifying narrow spec.""" """Wraps pull command to allow modifying narrow spec."""
wrappedextraprepare = util.nullcontextmanager() wrappedextraprepare = util.nullcontextmanager()
if repository.NARROW_REQUIREMENT in repo.requirements: if repository.NARROW_REQUIREMENT in repo.requirements:
def pullbundle2extraprepare_widen(orig, pullop, kwargs): def pullbundle2extraprepare_widen(orig, pullop, kwargs):
orig(pullop, kwargs) orig(pullop, kwargs)
if opts.get(r'depth'): if opts.get('depth'):
kwargs[b'depth'] = opts[r'depth'] kwargs[b'depth'] = opts['depth']
wrappedextraprepare = extensions.wrappedfunction( wrappedextraprepare = extensions.wrappedfunction(
exchange, b'_pullbundle2extraprepare', pullbundle2extraprepare_widen exchange, b'_pullbundle2extraprepare', pullbundle2extraprepare_widen
) )
with wrappedextraprepare: with wrappedextraprepare:
return orig(ui, repo, *args, **opts) return orig(ui, repo, *args, **opts)
def archivenarrowcmd(orig, ui, repo, *args, **opts): def archivenarrowcmd(orig, ui, repo, *args, **opts):
"""Wraps archive command to narrow the default includes.""" """Wraps archive command to narrow the default includes."""
if repository.NARROW_REQUIREMENT in repo.requirements: if repository.NARROW_REQUIREMENT in repo.requirements:
repo_includes, repo_excludes = repo.narrowpats repo_includes, repo_excludes = repo.narrowpats
includes = set(opts.get(r'include', [])) includes = set(opts.get('include', []))
excludes = set(opts.get(r'exclude', [])) excludes = set(opts.get('exclude', []))
includes, excludes, unused_invalid = narrowspec.restrictpatterns( includes, excludes, unused_invalid = narrowspec.restrictpatterns(
includes, excludes, repo_includes, repo_excludes includes, excludes, repo_includes, repo_excludes
) )
if includes: if includes:
opts[r'include'] = includes opts['include'] = includes
if excludes: if excludes:
opts[r'exclude'] = excludes opts['exclude'] = excludes
return orig(ui, repo, *args, **opts) return orig(ui, repo, *args, **opts)
def pullbundle2extraprepare(orig, pullop, kwargs): def pullbundle2extraprepare(orig, pullop, kwargs):
repo = pullop.repo repo = pullop.repo
if repository.NARROW_REQUIREMENT not in repo.requirements: if repository.NARROW_REQUIREMENT not in repo.requirements:
return orig(pullop, kwargs) return orig(pullop, kwargs)

hgext/narrow/narrowwirepeer.py

chunks = bundler.getchunks() chunks = bundler.getchunks()
return wireprototypes.streamres( return wireprototypes.streamres(
gen=chunks, prefer_uncompressed=preferuncompressed gen=chunks, prefer_uncompressed=preferuncompressed
) )
def peernarrowwiden(remote, **kwargs): def peernarrowwiden(remote, **kwargs):
for ch in (r'commonheads', r'known'): for ch in ('commonheads', 'known'):
kwargs[ch] = wireprototypes.encodelist(kwargs[ch]) kwargs[ch] = wireprototypes.encodelist(kwargs[ch])
for ch in (r'oldincludes', r'newincludes', r'oldexcludes', r'newexcludes'): for ch in ('oldincludes', 'newincludes', 'oldexcludes', 'newexcludes'):
kwargs[ch] = b','.join(kwargs[ch]) kwargs[ch] = b','.join(kwargs[ch])
kwargs[r'ellipses'] = b'%i' % bool(kwargs[r'ellipses']) kwargs['ellipses'] = b'%i' % bool(kwargs['ellipses'])
f = remote._callcompressable(b'narrow_widen', **kwargs) f = remote._callcompressable(b'narrow_widen', **kwargs)
return bundle2.getunbundler(remote.ui, f) return bundle2.getunbundler(remote.ui, f)

hgext/notify.py

return return
try: try:
msg = mail.parsebytes(data) msg = mail.parsebytes(data)
except emailerrors.MessageParseError as inst: except emailerrors.MessageParseError as inst:
raise error.Abort(inst) raise error.Abort(inst)
# store sender and subject # store sender and subject
sender = msg[r'From'] sender = msg['From']
subject = msg[r'Subject'] subject = msg['Subject']
if sender is not None: if sender is not None:
sender = mail.headdecode(sender) sender = mail.headdecode(sender)
if subject is not None: if subject is not None:
subject = mail.headdecode(subject) subject = mail.headdecode(subject)
del msg[r'From'], msg[r'Subject'] del msg['From'], msg['Subject']
if not msg.is_multipart(): if not msg.is_multipart():
# create fresh mime message from scratch # create fresh mime message from scratch
# (multipart templates must take care of this themselves) # (multipart templates must take care of this themselves)
headers = msg.items() headers = msg.items()
payload = msg.get_payload(decode=pycompat.ispy3) payload = msg.get_payload(decode=pycompat.ispy3)
# for notification prefer readability over data precision # for notification prefer readability over data precision
msg = mail.mimeencode(self.ui, payload, self.charsets, self.test) msg = mail.mimeencode(self.ui, payload, self.charsets, self.test)
# reinstate custom headers # reinstate custom headers
for k, v in headers: for k, v in headers:
msg[k] = v msg[k] = v
msg[r'Date'] = encoding.strfromlocal( msg['Date'] = encoding.strfromlocal(
dateutil.datestr(format=b"%a, %d %b %Y %H:%M:%S %1%2") dateutil.datestr(format=b"%a, %d %b %Y %H:%M:%S %1%2")
) )
# try to make subject line exist and be useful # try to make subject line exist and be useful
if not subject: if not subject:
if count > 1: if count > 1:
subject = _(b'%s: %d new changesets') % (self.root, count) subject = _(b'%s: %d new changesets') % (self.root, count)
else: else:
s = ctx.description().lstrip().split(b'\n', 1)[0].rstrip() s = ctx.description().lstrip().split(b'\n', 1)[0].rstrip()
subject = b'%s: %s' % (self.root, s) subject = b'%s: %s' % (self.root, s)
maxsubject = int(self.ui.config(b'notify', b'maxsubject')) maxsubject = int(self.ui.config(b'notify', b'maxsubject'))
if maxsubject: if maxsubject:
subject = stringutil.ellipsis(subject, maxsubject) subject = stringutil.ellipsis(subject, maxsubject)
msg[r'Subject'] = encoding.strfromlocal( msg['Subject'] = encoding.strfromlocal(
mail.headencode(self.ui, subject, self.charsets, self.test) mail.headencode(self.ui, subject, self.charsets, self.test)
) )
# try to make message have proper sender # try to make message have proper sender
if not sender: if not sender:
sender = self.ui.config(b'email', b'from') or self.ui.username() sender = self.ui.config(b'email', b'from') or self.ui.username()
if b'@' not in sender or b'@localhost' in sender: if b'@' not in sender or b'@localhost' in sender:
sender = self.fixmail(sender) sender = self.fixmail(sender)
msg[r'From'] = encoding.strfromlocal( msg['From'] = encoding.strfromlocal(
mail.addressencode(self.ui, sender, self.charsets, self.test) mail.addressencode(self.ui, sender, self.charsets, self.test)
) )
msg[r'X-Hg-Notification'] = r'changeset %s' % ctx msg['X-Hg-Notification'] = 'changeset %s' % ctx
if not msg[r'Message-Id']: if not msg['Message-Id']:
msg[r'Message-Id'] = messageid(ctx, self.domain, self.messageidseed) msg['Message-Id'] = messageid(ctx, self.domain, self.messageidseed)
msg[r'To'] = encoding.strfromlocal(b', '.join(sorted(subs))) msg['To'] = encoding.strfromlocal(b', '.join(sorted(subs)))
msgtext = msg.as_bytes() if pycompat.ispy3 else msg.as_string() msgtext = msg.as_bytes() if pycompat.ispy3 else msg.as_string()
if self.test: if self.test:
self.ui.write(msgtext) self.ui.write(msgtext)
if not msgtext.endswith(b'\n'): if not msgtext.endswith(b'\n'):
self.ui.write(b'\n') self.ui.write(b'\n')
else: else:
self.ui.status( self.ui.status(
_(b'notify: sending %d subscribers %d changes\n') _(b'notify: sending %d subscribers %d changes\n')
% (len(subs), count) % (len(subs), count)
) )
mail.sendmail( mail.sendmail(
self.ui, self.ui,
emailutils.parseaddr(msg[r'From'])[1], emailutils.parseaddr(msg['From'])[1],
subs, subs,
msgtext, msgtext,
mbox=self.mbox, mbox=self.mbox,
) )
def diff(self, ctx, ref=None): def diff(self, ctx, ref=None):
maxdiff = int(self.ui.config(b'notify', b'maxdiff')) maxdiff = int(self.ui.config(b'notify', b'maxdiff'))

hgext/patchbomb.py

patchname = cmdutil.makefilename( patchname = cmdutil.makefilename(
repo[node], b'%b-%n.patch', seqno=idx, total=total repo[node], b'%b-%n.patch', seqno=idx, total=total
) )
else: else:
patchname = cmdutil.makefilename(repo[node], b'%b.patch') patchname = cmdutil.makefilename(repo[node], b'%b.patch')
disposition = r'inline' disposition = r'inline'
if opts.get(b'attach'): if opts.get(b'attach'):
disposition = r'attachment' disposition = r'attachment'
p[r'Content-Disposition'] = ( p['Content-Disposition'] = (
disposition + r'; filename=' + encoding.strfromlocal(patchname) disposition + '; filename=' + encoding.strfromlocal(patchname)
) )
msg.attach(p) msg.attach(p)
else: else:
msg = mail.mimetextpatch(body, display=opts.get(b'test')) msg = mail.mimetextpatch(body, display=opts.get(b'test'))
prefix = _formatprefix( prefix = _formatprefix(
ui, repo, rev, opts.get(b'flag'), idx, total, numbered ui, repo, rev, opts.get(b'flag'), idx, total, numbered
) )
The bundle is a returned as a single in-memory binary blob. The bundle is a returned as a single in-memory binary blob.
""" """
ui = repo.ui ui = repo.ui
tmpdir = pycompat.mkdtemp(prefix=b'hg-email-bundle-') tmpdir = pycompat.mkdtemp(prefix=b'hg-email-bundle-')
tmpfn = os.path.join(tmpdir, b'bundle') tmpfn = os.path.join(tmpdir, b'bundle')
btype = ui.config(b'patchbomb', b'bundletype') btype = ui.config(b'patchbomb', b'bundletype')
if btype: if btype:
opts[r'type'] = btype opts['type'] = btype
try: try:
commands.bundle(ui, repo, tmpfn, dest, **opts) commands.bundle(ui, repo, tmpfn, dest, **opts)
return util.readfile(tmpfn) return util.readfile(tmpfn)
finally: finally:
try: try:
os.unlink(tmpfn) os.unlink(tmpfn)
except OSError: except OSError:
pass pass
os.rmdir(tmpdir) os.rmdir(tmpdir)
def _getdescription(repo, defaultbody, sender, **opts): def _getdescription(repo, defaultbody, sender, **opts):
"""obtain the body of the introduction message and return it """obtain the body of the introduction message and return it
This is also used for the body of email with an attached bundle. This is also used for the body of email with an attached bundle.
The body can be obtained either from the command line option or entered by The body can be obtained either from the command line option or entered by
the user through the editor. the user through the editor.
""" """
ui = repo.ui ui = repo.ui
if opts.get(r'desc'): if opts.get('desc'):
body = open(opts.get(r'desc')).read() body = open(opts.get('desc')).read()
else: else:
ui.write( ui.write(
_(b'\nWrite the introductory message for the patch series.\n\n') _(b'\nWrite the introductory message for the patch series.\n\n')
) )
body = ui.edit( body = ui.edit(
defaultbody, sender, repopath=repo.path, action=b'patchbombbody' defaultbody, sender, repopath=repo.path, action=b'patchbombbody'
) )
# Save series description in case sendmail fails # Save series description in case sendmail fails
msgfile = repo.vfs(b'last-email.txt', b'wb') msgfile = repo.vfs(b'last-email.txt', b'wb')
msgfile.write(body) msgfile.write(body)
msgfile.close() msgfile.close()
return body return body
def _getbundlemsgs(repo, sender, bundle, **opts): def _getbundlemsgs(repo, sender, bundle, **opts):
"""Get the full email for sending a given bundle """Get the full email for sending a given bundle
This function returns a list of "email" tuples (subject, content, None). This function returns a list of "email" tuples (subject, content, None).
The list is always one message long in that case. The list is always one message long in that case.
""" """
ui = repo.ui ui = repo.ui
_charsets = mail._charsets(ui) _charsets = mail._charsets(ui)
subj = opts.get(r'subject') or prompt( subj = opts.get('subject') or prompt(
ui, b'Subject:', b'A bundle for your repository' ui, b'Subject:', b'A bundle for your repository'
) )
body = _getdescription(repo, b'', sender, **opts) body = _getdescription(repo, b'', sender, **opts)
msg = emimemultipart.MIMEMultipart() msg = emimemultipart.MIMEMultipart()
if body: if body:
msg.attach(mail.mimeencode(ui, body, _charsets, opts.get(r'test'))) msg.attach(mail.mimeencode(ui, body, _charsets, opts.get('test')))
datapart = emimebase.MIMEBase(r'application', r'x-mercurial-bundle') datapart = emimebase.MIMEBase('application', 'x-mercurial-bundle')
datapart.set_payload(bundle) datapart.set_payload(bundle)
bundlename = b'%s.hg' % opts.get(r'bundlename', b'bundle') bundlename = b'%s.hg' % opts.get('bundlename', b'bundle')
datapart.add_header( datapart.add_header(
r'Content-Disposition', 'Content-Disposition',
r'attachment', 'attachment',
filename=encoding.strfromlocal(bundlename), filename=encoding.strfromlocal(bundlename),
) )
emailencoders.encode_base64(datapart) emailencoders.encode_base64(datapart)
msg.attach(datapart) msg.attach(datapart)
msg[b'Subject'] = mail.headencode(ui, subj, _charsets, opts.get(r'test')) msg[b'Subject'] = mail.headencode(ui, subj, _charsets, opts.get('test'))
return [(msg, subj, None)] return [(msg, subj, None)]
def _makeintro(repo, sender, revs, patches, **opts): def _makeintro(repo, sender, revs, patches, **opts):
"""make an introduction email, asking the user for content if needed """make an introduction email, asking the user for content if needed
email is returned as (subject, body, cumulative-diffstat)""" email is returned as (subject, body, cumulative-diffstat)"""
ui = repo.ui ui = repo.ui
_charsets = mail._charsets(ui) _charsets = mail._charsets(ui)
# use the last revision which is likely to be a bookmarked head # use the last revision which is likely to be a bookmarked head
prefix = _formatprefix( prefix = _formatprefix(
ui, repo, revs.last(), opts.get(r'flag'), 0, len(patches), numbered=True ui, repo, revs.last(), opts.get('flag'), 0, len(patches), numbered=True
) )
subj = opts.get(r'subject') or prompt( subj = opts.get('subject') or prompt(
ui, b'(optional) Subject: ', rest=prefix, default=b'' ui, b'(optional) Subject: ', rest=prefix, default=b''
) )
if not subj: if not subj:
return None # skip intro if the user doesn't bother return None # skip intro if the user doesn't bother
subj = prefix + b' ' + subj subj = prefix + b' ' + subj
body = b'' body = b''
if opts.get(r'diffstat'): if opts.get('diffstat'):
# generate a cumulative diffstat of the whole patch series # generate a cumulative diffstat of the whole patch series
diffstat = patch.diffstat(sum(patches, [])) diffstat = patch.diffstat(sum(patches, []))
body = b'\n' + diffstat body = b'\n' + diffstat
else: else:
diffstat = None diffstat = None
body = _getdescription(repo, body, sender, **opts) body = _getdescription(repo, body, sender, **opts)
msg = mail.mimeencode(ui, body, _charsets, opts.get(r'test')) msg = mail.mimeencode(ui, body, _charsets, opts.get('test'))
msg[b'Subject'] = mail.headencode(ui, subj, _charsets, opts.get(r'test')) msg[b'Subject'] = mail.headencode(ui, subj, _charsets, opts.get('test'))
return (msg, subj, diffstat) return (msg, subj, diffstat)
def _getpatchmsgs(repo, sender, revs, patchnames=None, **opts): def _getpatchmsgs(repo, sender, revs, patchnames=None, **opts):
"""return a list of emails from a list of patches """return a list of emails from a list of patches
This involves introduction message creation if necessary. This involves introduction message creation if necessary.
or ui.config(b'patchbomb', b'from') or ui.config(b'patchbomb', b'from')
or prompt(ui, b'From', ui.username()) or prompt(ui, b'From', ui.username())
) )
if bundle: if bundle:
stropts = pycompat.strkwargs(opts) stropts = pycompat.strkwargs(opts)
bundledata = _getbundle(repo, dest, **stropts) bundledata = _getbundle(repo, dest, **stropts)
bundleopts = stropts.copy() bundleopts = stropts.copy()
bundleopts.pop(r'bundle', None) # already processed bundleopts.pop('bundle', None) # already processed
msgs = _getbundlemsgs(repo, sender, bundledata, **bundleopts) msgs = _getbundlemsgs(repo, sender, bundledata, **bundleopts)
else: else:
msgs = _getpatchmsgs(repo, sender, revs, **pycompat.strkwargs(opts)) msgs = _getpatchmsgs(repo, sender, revs, **pycompat.strkwargs(opts))
showaddrs = [] showaddrs = []
def getaddrs(header, ask=False, default=None): def getaddrs(header, ask=False, default=None):
configkey = header.lower() configkey = header.lower()

hgext/phabricator.py

def sanitiserequest(request): def sanitiserequest(request):
request.body = re.sub( request.body = re.sub(
br'cli-[a-z0-9]+', br'cli-hahayouwish', request.body br'cli-[a-z0-9]+', br'cli-hahayouwish', request.body
) )
return request return request
def sanitiseresponse(response): def sanitiseresponse(response):
if r'set-cookie' in response[r'headers']: if 'set-cookie' in response['headers']:
del response[r'headers'][r'set-cookie'] del response['headers']['set-cookie']
return response return response
def decorate(fn): def decorate(fn):
def inner(*args, **kwargs): def inner(*args, **kwargs):
cassette = pycompat.fsdecode(kwargs.pop(r'test_vcr', None)) cassette = pycompat.fsdecode(kwargs.pop('test_vcr', None))
if cassette: if cassette:
import hgdemandimport import hgdemandimport
with hgdemandimport.deactivated(): with hgdemandimport.deactivated():
import vcr as vcrmod import vcr as vcrmod
import vcr.stubs as stubs import vcr.stubs as stubs
vcr = vcrmod.VCR( vcr = vcrmod.VCR(
serializer=r'json', serializer='json',
before_record_request=sanitiserequest, before_record_request=sanitiserequest,
before_record_response=sanitiseresponse, before_record_response=sanitiseresponse,
custom_patches=[ custom_patches=[
( (
urlmod, urlmod,
r'httpconnection', 'httpconnection',
stubs.VCRHTTPConnection, stubs.VCRHTTPConnection,
), ),
( (
urlmod, urlmod,
r'httpsconnection', 'httpsconnection',
stubs.VCRHTTPSConnection, stubs.VCRHTTPSConnection,
), ),
], ],
) )
vcr.register_matcher(r'hgmatcher', hgmatcher) vcr.register_matcher('hgmatcher', hgmatcher)
with vcr.use_cassette(cassette, match_on=[r'hgmatcher']): with vcr.use_cassette(cassette, match_on=['hgmatcher']):
return fn(*args, **kwargs) return fn(*args, **kwargs)
return fn(*args, **kwargs) return fn(*args, **kwargs)
inner.__name__ = fn.__name__ inner.__name__ = fn.__name__
inner.__doc__ = fn.__doc__ inner.__doc__ = fn.__doc__
return command( return command(
name, name,
fullflags, fullflags,
m = _differentialrevisiontagre.match(tag) m = _differentialrevisiontagre.match(tag)
if m: if m:
toconfirm[node] = (0, set(precnodes), int(m.group(1))) toconfirm[node] = (0, set(precnodes), int(m.group(1)))
continue continue
# Check commit message # Check commit message
m = _differentialrevisiondescre.search(ctx.description()) m = _differentialrevisiondescre.search(ctx.description())
if m: if m:
toconfirm[node] = (1, set(precnodes), int(m.group(r'id'))) toconfirm[node] = (1, set(precnodes), int(m.group('id')))
# Double check if tags are genuine by collecting all old nodes from # Double check if tags are genuine by collecting all old nodes from
# Phabricator, and expect precursors overlap with it. # Phabricator, and expect precursors overlap with it.
if toconfirm: if toconfirm:
drevs = [drev for force, precs, drev in toconfirm.values()] drevs = [drev for force, precs, drev in toconfirm.values()]
alldiffs = callconduit( alldiffs = callconduit(
unfi.ui, b'differential.querydiffs', {b'revisionIDs': drevs} unfi.ui, b'differential.querydiffs', {b'revisionIDs': drevs}
) )
if revid: if revid:
action = b'updated' action = b'updated'
else: else:
action = b'created' action = b'created'
# Create a local tag to note the association, if commit message # Create a local tag to note the association, if commit message
# does not have it already # does not have it already
m = _differentialrevisiondescre.search(ctx.description()) m = _differentialrevisiondescre.search(ctx.description())
if not m or int(m.group(r'id')) != newrevid: if not m or int(m.group('id')) != newrevid:
tagname = b'D%d' % newrevid tagname = b'D%d' % newrevid
tags.tag( tags.tag(
repo, repo,
tagname, tagname,
ctx.node(), ctx.node(),
message=None, message=None,
user=None, user=None,
date=None, date=None,
def template_review(context, mapping): def template_review(context, mapping):
""":phabreview: Object describing the review for this changeset. """:phabreview: Object describing the review for this changeset.
Has attributes `url` and `id`. Has attributes `url` and `id`.
""" """
ctx = context.resource(mapping, b'ctx') ctx = context.resource(mapping, b'ctx')
m = _differentialrevisiondescre.search(ctx.description()) m = _differentialrevisiondescre.search(ctx.description())
if m: if m:
return templateutil.hybriddict( return templateutil.hybriddict(
{b'url': m.group(r'url'), b'id': b"D%s" % m.group(r'id'),} {b'url': m.group('url'), b'id': b"D%s" % m.group('id'),}
) )
else: else:
tags = ctx.repo().nodetags(ctx.node()) tags = ctx.repo().nodetags(ctx.node())
for t in tags: for t in tags:
if _differentialrevisiontagre.match(t): if _differentialrevisiontagre.match(t):
url = ctx.repo().ui.config(b'phabricator', b'url') url = ctx.repo().ui.config(b'phabricator', b'url')
if not url.endswith(b'/'): if not url.endswith(b'/'):
url += b'/' url += b'/'
url += t url += t
return templateutil.hybriddict({b'url': url, b'id': t,}) return templateutil.hybriddict({b'url': url, b'id': t,})
return None return None

hgext/rebase.py

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' b'Call rebase after pull if the latter has been invoked with --rebase'
if opts.get(r'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(r'update'): if opts.get('update'):
del opts[r'update'] del opts['update']
ui.debug( ui.debug(
b'--update and --rebase are not compatible, ignoring ' b'--update and --rebase are not compatible, ignoring '
b'the update flag\n' b'the update flag\n'
) )
cmdutil.checkunfinished(repo, skipmerge=True) cmdutil.checkunfinished(repo, skipmerge=True)
cmdutil.bailifchanged( cmdutil.bailifchanged(
repo, repo,
try: try:
ret = orig(ui, repo, *args, **opts) ret = orig(ui, repo, *args, **opts)
finally: finally:
commands.postincoming = origpostincoming commands.postincoming = origpostincoming
revspostpull = len(repo) revspostpull = len(repo)
if revspostpull > revsprepull: if revspostpull > revsprepull:
# --rev option from pull conflict with rebase own --rev # --rev option from pull conflict with rebase own --rev
# dropping it # dropping it
if r'rev' in opts: if 'rev' in opts:
del opts[r'rev'] del opts['rev']
# positional argument from pull conflicts with rebase's own # positional argument from pull conflicts with rebase's own
# --source. # --source.
if r'source' in opts: if 'source' in opts:
del opts[r'source'] del opts['source']
# revsprepull is the len of the repo, not revnum of tip. # revsprepull is the len of the repo, not revnum of tip.
destspace = list(repo.changelog.revs(start=revsprepull)) destspace = list(repo.changelog.revs(start=revsprepull))
opts[r'_destspace'] = destspace opts['_destspace'] = destspace
try: try:
rebase(ui, repo, **opts) rebase(ui, repo, **opts)
except error.NoMergeDestAbort: except error.NoMergeDestAbort:
# we can maybe update instead # we can maybe update instead
rev, _a, _b = destutil.destupdate(repo) rev, _a, _b = destutil.destupdate(repo)
if rev == repo[b'.'].rev(): if rev == repo[b'.'].rev():
ui.status(_(b'nothing to rebase\n')) ui.status(_(b'nothing to rebase\n'))
else: else:
ui.status(_(b'nothing to rebase - updating instead\n')) ui.status(_(b'nothing to rebase - updating instead\n'))
# not passing argument to get the bare update behavior # not passing argument to get the bare update behavior
# with warning and trumpets # with warning and trumpets
commands.update(ui, repo) commands.update(ui, repo)
else: else:
if opts.get(r'tool'): if opts.get('tool'):
raise error.Abort(_(b'--tool can only be used with --rebase')) raise error.Abort(_(b'--tool can only be used with --rebase'))
ret = orig(ui, repo, *args, **opts) ret = orig(ui, repo, *args, **opts)
return ret return ret
def _filterobsoleterevs(repo, revs): def _filterobsoleterevs(repo, revs):
"""returns a set of the obsolete revisions in revs""" """returns a set of the obsolete revisions in revs"""

hgext/record.py

opts["interactive"] = True opts["interactive"] = True
overrides = {(b'experimental', b'crecord'): False} overrides = {(b'experimental', b'crecord'): False}
with ui.configoverride(overrides, b'record'): with ui.configoverride(overrides, b'record'):
return commands.commit(ui, repo, *pats, **opts) return commands.commit(ui, repo, *pats, **opts)
def qrefresh(origfn, ui, repo, *pats, **opts): def qrefresh(origfn, ui, repo, *pats, **opts):
if not opts[r'interactive']: if not opts['interactive']:
return origfn(ui, repo, *pats, **opts) return origfn(ui, repo, *pats, **opts)
mq = extensions.find(b'mq') mq = extensions.find(b'mq')
def committomq(ui, repo, *pats, **opts): def committomq(ui, repo, *pats, **opts):
# At this point the working copy contains only changes that # At this point the working copy contains only changes that
# were accepted. All other changes were reverted. # were accepted. All other changes were reverted.
# We can't pass *pats here since qrefresh will undo all other # We can't pass *pats here since qrefresh will undo all other
try: try:
mq = extensions.find(b'mq') mq = extensions.find(b'mq')
except KeyError: except KeyError:
raise error.Abort(_(b"'mq' extension not loaded")) raise error.Abort(_(b"'mq' extension not loaded"))
repo.mq.checkpatchname(patch) repo.mq.checkpatchname(patch)
def committomq(ui, repo, *pats, **opts): def committomq(ui, repo, *pats, **opts):
opts[r'checkname'] = False opts['checkname'] = False
mq.new(ui, repo, patch, *pats, **opts) mq.new(ui, repo, patch, *pats, **opts)
overrides = {(b'experimental', b'crecord'): False} overrides = {(b'experimental', b'crecord'): False}
with ui.configoverride(overrides, b'record'): with ui.configoverride(overrides, b'record'):
cmdutil.checkunfinished(repo) cmdutil.checkunfinished(repo)
cmdutil.dorecord( cmdutil.dorecord(
ui, ui,
repo, repo,
committomq, committomq,
cmdsuggest, cmdsuggest,
False, False,
cmdutil.recordfilter, cmdutil.recordfilter,
*pats, *pats,
**opts **opts
) )
def qnew(origfn, ui, repo, patch, *args, **opts): def qnew(origfn, ui, repo, patch, *args, **opts):
if opts[r'interactive']: if opts['interactive']:
return _qrecord(None, ui, repo, patch, *args, **opts) return _qrecord(None, ui, repo, patch, *args, **opts)
return origfn(ui, repo, patch, *args, **opts) return origfn(ui, repo, patch, *args, **opts)
def uisetup(ui): def uisetup(ui):
try: try:
mq = extensions.find(b'mq') mq = extensions.find(b'mq')
except KeyError: except KeyError:

hgext/remotefilelog/__init__.py

extensions.wrapcommand( extensions.wrapcommand(
commands.table, b'debugindexdot', debugcommands.debugindexdot commands.table, b'debugindexdot', debugcommands.debugindexdot
) )
extensions.wrapcommand(commands.table, b'log', log) extensions.wrapcommand(commands.table, b'log', log)
extensions.wrapcommand(commands.table, b'pull', pull) extensions.wrapcommand(commands.table, b'pull', pull)
# Prevent 'hg manifest --all' # Prevent 'hg manifest --all'
def _manifest(orig, ui, repo, *args, **opts): def _manifest(orig, ui, repo, *args, **opts):
if isenabled(repo) and opts.get(r'all'): if isenabled(repo) and opts.get('all'):
raise error.Abort(_(b"--all is not supported in a shallow repo")) raise error.Abort(_(b"--all is not supported in a shallow repo"))
return orig(ui, repo, *args, **opts) return orig(ui, repo, *args, **opts)
extensions.wrapcommand(commands.table, b"manifest", _manifest) extensions.wrapcommand(commands.table, b"manifest", _manifest)
# Wrap remotefilelog with lfs code # Wrap remotefilelog with lfs code
def _lfsloaded(loaded=False): def _lfsloaded(loaded=False):
# disappointing hacks below # disappointing hacks below
extensions.wrapfunction(scmutil, b'getrenamedfn', getrenamedfn) extensions.wrapfunction(scmutil, b'getrenamedfn', getrenamedfn)
extensions.wrapfunction(revset, b'filelog', filelogrevset) extensions.wrapfunction(revset, b'filelog', filelogrevset)
revset.symbols[b'filelog'] = revset.filelog revset.symbols[b'filelog'] = revset.filelog
extensions.wrapfunction(cmdutil, b'walkfilerevs', walkfilerevs) extensions.wrapfunction(cmdutil, b'walkfilerevs', walkfilerevs)
def cloneshallow(orig, ui, repo, *args, **opts): def cloneshallow(orig, ui, repo, *args, **opts):
if opts.get(r'shallow'): if opts.get('shallow'):
repos = [] repos = []
def pull_shallow(orig, self, *args, **kwargs): def pull_shallow(orig, self, *args, **kwargs):
if not isenabled(self): if not isenabled(self):
repos.append(self.unfiltered()) repos.append(self.unfiltered())
# set up the client hooks so the post-clone update works # set up the client hooks so the post-clone update works
setupclient(self.ui, self.unfiltered()) setupclient(self.ui, self.unfiltered())
def setup_streamout(repo, remote): def setup_streamout(repo, remote):
# Replace remote.stream_out with a version that sends file # Replace remote.stream_out with a version that sends file
# patterns. # patterns.
def stream_out_shallow(orig): def stream_out_shallow(orig):
caps = remote.capabilities() caps = remote.capabilities()
if constants.NETWORK_CAP_LEGACY_SSH_GETFILES in caps: if constants.NETWORK_CAP_LEGACY_SSH_GETFILES in caps:
opts = {} opts = {}
if repo.includepattern: if repo.includepattern:
opts[r'includepattern'] = b'\0'.join( opts['includepattern'] = b'\0'.join(repo.includepattern)
repo.includepattern
)
if repo.excludepattern: if repo.excludepattern:
opts[r'excludepattern'] = b'\0'.join( opts['excludepattern'] = b'\0'.join(repo.excludepattern)
repo.excludepattern
)
return remote._callstream(b'stream_out_shallow', **opts) return remote._callstream(b'stream_out_shallow', **opts)
else: else:
return orig() return orig()
extensions.wrapfunction(remote, b'stream_out', stream_out_shallow) extensions.wrapfunction(remote, b'stream_out', stream_out_shallow)
def stream_wrap(orig, op): def stream_wrap(orig, op):
setup_streamout(op.repo, op.remote) setup_streamout(op.repo, op.remote)
extensions.wrapfunction( extensions.wrapfunction(
streamclone, b'canperformstreamclone', canperformstreamclone streamclone, b'canperformstreamclone', canperformstreamclone
) )
try: try:
orig(ui, repo, *args, **opts) orig(ui, repo, *args, **opts)
finally: finally:
if opts.get(r'shallow'): if opts.get('shallow'):
for r in repos: for r in repos:
if util.safehasattr(r, b'fileservice'): if util.safehasattr(r, b'fileservice'):
r.fileservice.close() r.fileservice.close()
def debugdatashallow(orig, *args, **kwds): def debugdatashallow(orig, *args, **kwds):
oldlen = remotefilelog.remotefilelog.__len__ oldlen = remotefilelog.remotefilelog.__len__
try: try:
elif not filesrepacked: elif not filesrepacked:
ui.warn(_(b"warning: no valid repos in repofile\n")) ui.warn(_(b"warning: no valid repos in repofile\n"))
def log(orig, ui, repo, *pats, **opts): def log(orig, ui, repo, *pats, **opts):
if not isenabled(repo): if not isenabled(repo):
return orig(ui, repo, *pats, **opts) return orig(ui, repo, *pats, **opts)
follow = opts.get(r'follow') follow = opts.get('follow')
revs = opts.get(r'rev') revs = opts.get('rev')
if pats: if pats:
# Force slowpath for non-follow patterns and follows that start from # Force slowpath for non-follow patterns and follows that start from
# non-working-copy-parent revs. # non-working-copy-parent revs.
if not follow or revs: if not follow or revs:
# This forces the slowpath # This forces the slowpath
opts[r'removed'] = True opts['removed'] = True
# If this is a non-follow log without any revs specified, recommend that # If this is a non-follow log without any revs specified, recommend that
# the user add -f to speed it up. # the user add -f to speed it up.
if not follow and not revs: if not follow and not revs:
match = scmutil.match(repo[b'.'], pats, pycompat.byteskwargs(opts)) match = scmutil.match(repo[b'.'], pats, pycompat.byteskwargs(opts))
isfile = not match.anypats() isfile = not match.anypats()
if isfile: if isfile:
for file in match.files(): for file in match.files():
None, None,
_(b'only repack packs (skip loose objects)'), _(b'only repack packs (skip loose objects)'),
None, None,
), ),
], ],
_(b'hg repack [OPTIONS]'), _(b'hg repack [OPTIONS]'),
) )
def repack_(ui, repo, *pats, **opts): def repack_(ui, repo, *pats, **opts):
if opts.get(r'background'): if opts.get('background'):
ensurestart = repo.ui.configbool(b'devel', b'remotefilelog.ensurestart') ensurestart = repo.ui.configbool(b'devel', b'remotefilelog.ensurestart')
repackmod.backgroundrepack( repackmod.backgroundrepack(
repo, repo,
incremental=opts.get(r'incremental'), incremental=opts.get('incremental'),
packsonly=opts.get(r'packsonly', False), packsonly=opts.get('packsonly', False),
ensurestart=ensurestart, ensurestart=ensurestart,
) )
return return
options = {b'packsonly': opts.get(r'packsonly')} options = {b'packsonly': opts.get('packsonly')}
try: try:
if opts.get(r'incremental'): if opts.get('incremental'):
repackmod.incrementalrepack(repo, options=options) repackmod.incrementalrepack(repo, options=options)
else: else:
repackmod.fullrepack(repo, options=options) repackmod.fullrepack(repo, options=options)
except repackmod.RepackAlreadyRunning as ex: except repackmod.RepackAlreadyRunning as ex:
# Don't propogate the exception if the repack is already in # Don't propogate the exception if the repack is already in
# progress, since we want the command to exit 0. # progress, since we want the command to exit 0.
repo.ui.warn(b'%s\n' % ex) repo.ui.warn(b'%s\n' % ex)

hgext/remotefilelog/basepack.py

node as nodemod, node as nodemod,
policy, policy,
pycompat, pycompat,
util, util,
vfs as vfsmod, vfs as vfsmod,
) )
from . import shallowutil from . import shallowutil
osutil = policy.importmod(r'osutil') osutil = policy.importmod('osutil')
# The pack version supported by this implementation. This will need to be # The pack version supported by this implementation. This will need to be
# rev'd whenever the byte format changes. Ex: changing the fanout prefix, # rev'd whenever the byte format changes. Ex: changing the fanout prefix,
# changing any of the int sizes, changing the delta algorithm, etc. # changing any of the int sizes, changing the delta algorithm, etc.
PACKVERSIONSIZE = 1 PACKVERSIONSIZE = 1
INDEXVERSIONSIZE = 2 INDEXVERSIONSIZE = 2
FANOUTSTART = INDEXVERSIONSIZE FANOUTSTART = INDEXVERSIONSIZE
shallowutil.mkstickygroupdir(ui, packdir) shallowutil.mkstickygroupdir(ui, packdir)
self.packfp, self.packpath = opener.mkstemp( self.packfp, self.packpath = opener.mkstemp(
suffix=self.PACKSUFFIX + b'-tmp' suffix=self.PACKSUFFIX + b'-tmp'
) )
self.idxfp, self.idxpath = opener.mkstemp( self.idxfp, self.idxpath = opener.mkstemp(
suffix=self.INDEXSUFFIX + b'-tmp' suffix=self.INDEXSUFFIX + b'-tmp'
) )
self.packfp = os.fdopen(self.packfp, r'wb+') self.packfp = os.fdopen(self.packfp, 'wb+')
self.idxfp = os.fdopen(self.idxfp, r'wb+') self.idxfp = os.fdopen(self.idxfp, 'wb+')
self.sha = hashlib.sha1() self.sha = hashlib.sha1()
self._closed = False self._closed = False
# The opener provides no way of doing permission fixup on files created # The opener provides no way of doing permission fixup on files created
# via mkstemp, so we must fix it ourselves. We can probably fix this # via mkstemp, so we must fix it ourselves. We can probably fix this
# upstream in vfs.mkstemp so we don't need to use the private method. # upstream in vfs.mkstemp so we don't need to use the private method.
opener._fixfilemode(opener.join(self.packpath)) opener._fixfilemode(opener.join(self.packpath))
opener._fixfilemode(opener.join(self.idxpath)) opener._fixfilemode(opener.join(self.idxpath))
config = 0 config = 0
if indexparams.fanoutprefix == LARGEFANOUTPREFIX: if indexparams.fanoutprefix == LARGEFANOUTPREFIX:
config = 0b10000000 config = 0b10000000
self.idxfp.write(struct.pack(b'!BB', self.VERSION, config)) self.idxfp.write(struct.pack(b'!BB', self.VERSION, config))
class indexparams(object): class indexparams(object):
__slots__ = ( __slots__ = (
r'fanoutprefix', 'fanoutprefix',
r'fanoutstruct', 'fanoutstruct',
r'fanoutcount', 'fanoutcount',
r'fanoutsize', 'fanoutsize',
r'indexstart', 'indexstart',
) )
def __init__(self, prefixsize, version): def __init__(self, prefixsize, version):
self.fanoutprefix = prefixsize self.fanoutprefix = prefixsize
# The struct pack format for fanout table location (i.e. the format that # The struct pack format for fanout table location (i.e. the format that
# converts the node prefix into an integer location in the fanout # converts the node prefix into an integer location in the fanout
# table). # table).

hgext/remotefilelog/basestore.py

class baseunionstore(object): class baseunionstore(object):
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
# If one of the functions that iterates all of the stores is about to # If one of the functions that iterates all of the stores is about to
# throw a KeyError, try this many times with a full refresh between # throw a KeyError, try this many times with a full refresh between
# attempts. A repack operation may have moved data from one store to # attempts. A repack operation may have moved data from one store to
# another while we were running. # another while we were running.
self.numattempts = kwargs.get(r'numretries', 0) + 1 self.numattempts = kwargs.get('numretries', 0) + 1
# If not-None, call this function on every retry and if the attempts are # If not-None, call this function on every retry and if the attempts are
# exhausted. # exhausted.
self.retrylog = kwargs.get(r'retrylog', None) self.retrylog = kwargs.get('retrylog', None)
def markforrefresh(self): def markforrefresh(self):
for store in self.stores: for store in self.stores:
if util.safehasattr(store, b'markforrefresh'): if util.safehasattr(store, b'markforrefresh'):
store.markforrefresh() store.markforrefresh()
@staticmethod @staticmethod
def retriable(fn): def retriable(fn):

hgext/remotefilelog/contentstore.py

DATA = 4 DATA = 4
class unioncontentstore(basestore.baseunionstore): class unioncontentstore(basestore.baseunionstore):
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
super(unioncontentstore, self).__init__(*args, **kwargs) super(unioncontentstore, self).__init__(*args, **kwargs)
self.stores = args self.stores = args
self.writestore = kwargs.get(r'writestore') self.writestore = kwargs.get('writestore')
# If allowincomplete==True then the union store can return partial # If allowincomplete==True then the union store can return partial
# delta chains, otherwise it will throw a KeyError if a full # delta chains, otherwise it will throw a KeyError if a full
# deltachain can't be found. # deltachain can't be found.
self.allowincomplete = kwargs.get(r'allowincomplete', False) self.allowincomplete = kwargs.get('allowincomplete', False)
def get(self, name, node): def get(self, name, node):
"""Fetches the full text revision contents of the given name+node pair. """Fetches the full text revision contents of the given name+node pair.
If the full text doesn't exist, throws a KeyError. If the full text doesn't exist, throws a KeyError.
Under the hood, this uses getdeltachain() across all the stores to build Under the hood, this uses getdeltachain() across all the stores to build
up a full chain to produce the full text. up a full chain to produce the full text.
""" """

hgext/remotefilelog/debugcommands.py

fileserverclient, fileserverclient,
historypack, historypack,
repack, repack,
shallowutil, shallowutil,
) )
def debugremotefilelog(ui, path, **opts): def debugremotefilelog(ui, path, **opts):
decompress = opts.get(r'decompress') decompress = opts.get('decompress')
size, firstnode, mapping = parsefileblob(path, decompress) size, firstnode, mapping = parsefileblob(path, decompress)
ui.status(_(b"size: %d bytes\n") % size) ui.status(_(b"size: %d bytes\n") % size)
ui.status(_(b"path: %s \n") % path) ui.status(_(b"path: %s \n") % path)
ui.status(_(b"key: %s \n") % (short(firstnode))) ui.status(_(b"key: %s \n") % (short(firstnode)))
ui.status(_(b"\n")) ui.status(_(b"\n"))
ui.status( ui.status(
r.add(fctx.data(), meta, t, fctx.linkrev(), p[0], p[1]) r.add(fctx.data(), meta, t, fctx.linkrev(), p[0], p[1])
return r return r
def debugindex(orig, ui, repo, file_=None, **opts): def debugindex(orig, ui, repo, file_=None, **opts):
"""dump the contents of an index file""" """dump the contents of an index file"""
if ( if (
opts.get(r'changelog') opts.get('changelog')
or opts.get(r'manifest') or opts.get('manifest')
or opts.get(r'dir') or opts.get('dir')
or not shallowutil.isenabled(repo) or not shallowutil.isenabled(repo)
or not repo.shallowmatch(file_) or not repo.shallowmatch(file_)
): ):
return orig(ui, repo, file_, **opts) return orig(ui, repo, file_, **opts)
r = buildtemprevlog(repo, file_) r = buildtemprevlog(repo, file_)
# debugindex like normal # debugindex like normal
pp = r.parents(node) pp = r.parents(node)
ui.write(b"\t%d -> %d\n" % (r.rev(pp[0]), i)) ui.write(b"\t%d -> %d\n" % (r.rev(pp[0]), i))
if pp[1] != nullid: if pp[1] != nullid:
ui.write(b"\t%d -> %d\n" % (r.rev(pp[1]), i)) ui.write(b"\t%d -> %d\n" % (r.rev(pp[1]), i))
ui.write(b"}\n") ui.write(b"}\n")
def verifyremotefilelog(ui, path, **opts): def verifyremotefilelog(ui, path, **opts):
decompress = opts.get(r'decompress') decompress = opts.get('decompress')
for root, dirs, files in os.walk(path): for root, dirs, files in os.walk(path):
for file in files: for file in files:
if file == b"repos": if file == b"repos":
continue continue
filepath = os.path.join(root, file) filepath = os.path.join(root, file)
size, firstnode, mapping = parsefileblob(filepath, decompress) size, firstnode, mapping = parsefileblob(filepath, decompress)
for p1, p2, linknode, copyfrom in pycompat.itervalues(mapping): for p1, p2, linknode, copyfrom in pycompat.itervalues(mapping):
def debugdatapack(ui, *paths, **opts): def debugdatapack(ui, *paths, **opts):
for path in paths: for path in paths:
if b'.data' in path: if b'.data' in path:
path = path[: path.index(b'.data')] path = path[: path.index(b'.data')]
ui.write(b"%s:\n" % path) ui.write(b"%s:\n" % path)
dpack = datapack.datapack(path) dpack = datapack.datapack(path)
node = opts.get(r'node') node = opts.get('node')
if node: if node:
deltachain = dpack.getdeltachain(b'', bin(node)) deltachain = dpack.getdeltachain(b'', bin(node))
dumpdeltachain(ui, deltachain, **opts) dumpdeltachain(ui, deltachain, **opts)
return return
if opts.get(r'long'): if opts.get('long'):
hashformatter = hex hashformatter = hex
hashlen = 42 hashlen = 42
else: else:
hashformatter = short hashformatter = short
hashlen = 14 hashlen = 14
lastfilename = None lastfilename = None
totaldeltasize = 0 totaldeltasize = 0

hgext/remotefilelog/metadatastore.py

from __future__ import absolute_import from __future__ import absolute_import
from mercurial.node import hex, nullid from mercurial.node import hex, nullid
from . import ( from . import (
basestore, basestore,
shallowutil, shallowutil,
) )
class unionmetadatastore(basestore.baseunionstore): class unionmetadatastore(basestore.baseunionstore):
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
super(unionmetadatastore, self).__init__(*args, **kwargs) super(unionmetadatastore, self).__init__(*args, **kwargs)
self.stores = args self.stores = args
self.writestore = kwargs.get(r'writestore') self.writestore = kwargs.get('writestore')
# If allowincomplete==True then the union store can return partial # If allowincomplete==True then the union store can return partial
# ancestor lists, otherwise it will throw a KeyError if a full # ancestor lists, otherwise it will throw a KeyError if a full
# history can't be found. # history can't be found.
self.allowincomplete = kwargs.get(r'allowincomplete', False) self.allowincomplete = kwargs.get('allowincomplete', False)
def getancestors(self, name, node, known=None): def getancestors(self, name, node, known=None):
"""Returns as many ancestors as we're aware of. """Returns as many ancestors as we're aware of.
return value: { return value: {
node: (p1, p2, linknode, copyfrom), node: (p1, p2, linknode, copyfrom),
... ...
} }

hgext/remotefilelog/remotefilectx.py

) )
self._ancestormap = ancestormap self._ancestormap = ancestormap
def size(self): def size(self):
return self._filelog.size(self._filenode) return self._filelog.size(self._filenode)
@propertycache @propertycache
def _changeid(self): def _changeid(self):
if r'_changeid' in self.__dict__: if '_changeid' in self.__dict__:
return self._changeid return self._changeid
elif r'_changectx' in self.__dict__: elif '_changectx' in self.__dict__:
return self._changectx.rev() return self._changectx.rev()
elif r'_descendantrev' in self.__dict__: elif '_descendantrev' in self.__dict__:
# this file context was created from a revision with a known # this file context was created from a revision with a known
# descendant, we can (lazily) correct for linkrev aliases # descendant, we can (lazily) correct for linkrev aliases
linknode = self._adjustlinknode( linknode = self._adjustlinknode(
self._path, self._filelog, self._filenode, self._descendantrev self._path, self._filelog, self._filenode, self._descendantrev
) )
return self._repo.unfiltered().changelog.rev(linknode) return self._repo.unfiltered().changelog.rev(linknode)
else: else:
return self.linkrev() return self.linkrev()
This method is different from linkrev because it take into account the This method is different from linkrev because it take into account the
changeset the filectx was created from. It ensures the returned changeset the filectx was created from. It ensures the returned
revision is one of its ancestors. This prevents bugs from revision is one of its ancestors. This prevents bugs from
'linkrev-shadowing' when a file revision is used by multiple 'linkrev-shadowing' when a file revision is used by multiple
changesets. changesets.
""" """
lkr = self.linkrev() lkr = self.linkrev()
attrs = vars(self) attrs = vars(self)
noctx = not (r'_changeid' in attrs or r'_changectx' in attrs) noctx = not ('_changeid' in attrs or r'_changectx' in attrs)
if noctx or self.rev() == lkr: if noctx or self.rev() == lkr:
return lkr return lkr
linknode = self._adjustlinknode( linknode = self._adjustlinknode(
self._path, self._path,
self._filelog, self._filelog,
self._filenode, self._filenode,
self.rev(), self.rev(),
inclusive=True, inclusive=True,
inclusive = True # we skipped the real (revless) source inclusive = True # we skipped the real (revless) source
else: else:
revs = [srcrev] revs = [srcrev]
if self._verifylinknode(revs, linknode): if self._verifylinknode(revs, linknode):
return linknode return linknode
commonlogkwargs = { commonlogkwargs = {
r'revs': b' '.join([hex(cl.node(rev)) for rev in revs]), 'revs': b' '.join([hex(cl.node(rev)) for rev in revs]),
r'fnode': hex(fnode), 'fnode': hex(fnode),
r'filepath': path, 'filepath': path,
r'user': shallowutil.getusername(repo.ui), 'user': shallowutil.getusername(repo.ui),
r'reponame': shallowutil.getreponame(repo.ui), 'reponame': shallowutil.getreponame(repo.ui),
} }
repo.ui.log(b'linkrevfixup', b'adjusting linknode\n', **commonlogkwargs) repo.ui.log(b'linkrevfixup', b'adjusting linknode\n', **commonlogkwargs)
pc = repo._phasecache pc = repo._phasecache
seenpublic = False seenpublic = False
iteranc = cl.ancestors(revs, inclusive=inclusive) iteranc = cl.ancestors(revs, inclusive=inclusive)
for ancrev in iteranc: for ancrev in iteranc:
f, n = result f, n = result
r = remotefilectx(self._repo, f, fileid=n, ancestormap=amap) r = remotefilectx(self._repo, f, fileid=n, ancestormap=amap)
return r return r
return None return None
def annotate(self, *args, **kwargs): def annotate(self, *args, **kwargs):
introctx = self introctx = self
prefetchskip = kwargs.pop(r'prefetchskip', None) prefetchskip = kwargs.pop('prefetchskip', None)
if prefetchskip: if prefetchskip:
# use introrev so prefetchskip can be accurately tested # use introrev so prefetchskip can be accurately tested
introrev = self.introrev() introrev = self.introrev()
if self.rev() != introrev: if self.rev() != introrev:
introctx = remotefilectx( introctx = remotefilectx(
self._repo, self._repo,
self._path, self._path,
changeid=introrev, changeid=introrev,

hgext/remotefilelog/repack.py

constants, constants,
contentstore, contentstore,
datapack, datapack,
historypack, historypack,
metadatastore, metadatastore,
shallowutil, shallowutil,
) )
osutil = policy.importmod(r'osutil') osutil = policy.importmod('osutil')
class RepackAlreadyRunning(error.Abort): class RepackAlreadyRunning(error.Abort):
pass pass
def backgroundrepack( def backgroundrepack(
repo, incremental=True, packsonly=False, ensurestart=False repo, incremental=True, packsonly=False, ensurestart=False
self.created.add(value) self.created.add(value)
class repackentry(object): class repackentry(object):
"""Simple class representing a single revision entry in the repackledger. """Simple class representing a single revision entry in the repackledger.
""" """
__slots__ = ( __slots__ = (
r'filename', 'filename',
r'node', 'node',
r'datasource', 'datasource',
r'historysource', 'historysource',
r'datarepacked', 'datarepacked',
r'historyrepacked', 'historyrepacked',
r'gced', 'gced',
) )
def __init__(self, filename, node): def __init__(self, filename, node):
self.filename = filename self.filename = filename
self.node = node self.node = node
# If the revision has a data entry in the source # If the revision has a data entry in the source
self.datasource = False self.datasource = False
# If the revision has a history entry in the source # If the revision has a history entry in the source

hgext/remotefilelog/shallowbundle.py

def makechangegroup(orig, repo, outgoing, version, source, *args, **kwargs): def makechangegroup(orig, repo, outgoing, version, source, *args, **kwargs):
if not shallowutil.isenabled(repo): if not shallowutil.isenabled(repo):
return orig(repo, outgoing, version, source, *args, **kwargs) return orig(repo, outgoing, version, source, *args, **kwargs)
original = repo.shallowmatch original = repo.shallowmatch
try: try:
# if serving, only send files the clients has patterns for # if serving, only send files the clients has patterns for
if source == b'serve': if source == b'serve':
bundlecaps = kwargs.get(r'bundlecaps') bundlecaps = kwargs.get('bundlecaps')
includepattern = None includepattern = None
excludepattern = None excludepattern = None
for cap in bundlecaps or []: for cap in bundlecaps or []:
if cap.startswith(b"includepattern="): if cap.startswith(b"includepattern="):
raw = cap[len(b"includepattern=") :] raw = cap[len(b"includepattern=") :]
if raw: if raw:
includepattern = raw.split(b'\0') includepattern = raw.split(b'\0')
elif cap.startswith(b"excludepattern="): elif cap.startswith(b"excludepattern="):

hgext/share.py

# Wrap clone command to pass auto share options. # Wrap clone command to pass auto share options.
def clone(orig, ui, source, *args, **opts): def clone(orig, ui, source, *args, **opts):
pool = ui.config(b'share', b'pool') pool = ui.config(b'share', b'pool')
if pool: if pool:
pool = util.expandpath(pool) pool = util.expandpath(pool)
opts[r'shareopts'] = { opts['shareopts'] = {
b'pool': pool, b'pool': pool,
b'mode': ui.config(b'share', b'poolnaming'), b'mode': ui.config(b'share', b'poolnaming'),
} }
return orig(ui, source, *args, **opts) return orig(ui, source, *args, **opts)
def extsetup(ui): def extsetup(ui):

hgext/sparse.py

revs = revs.filter(ctxmatch) revs = revs.filter(ctxmatch)
return revs return revs
extensions.wrapfunction(logcmdutil, b'_initialrevs', _initialrevs) extensions.wrapfunction(logcmdutil, b'_initialrevs', _initialrevs)
def _clonesparsecmd(orig, ui, repo, *args, **opts): def _clonesparsecmd(orig, ui, repo, *args, **opts):
include_pat = opts.get(r'include') include_pat = opts.get('include')
exclude_pat = opts.get(r'exclude') exclude_pat = opts.get('exclude')
enableprofile_pat = opts.get(r'enable_profile') enableprofile_pat = opts.get('enable_profile')
narrow_pat = opts.get(r'narrow') narrow_pat = opts.get('narrow')
include = exclude = enableprofile = False include = exclude = enableprofile = False
if include_pat: if include_pat:
pat = include_pat pat = include_pat
include = True include = True
if exclude_pat: if exclude_pat:
pat = exclude_pat pat = exclude_pat
exclude = True exclude = True
if enableprofile_pat: if enableprofile_pat:
b's', b's',
b'sparse', b'sparse',
None, None,
b'also include directories of added files in sparse config', b'also include directories of added files in sparse config',
) )
) )
def _add(orig, ui, repo, *pats, **opts): def _add(orig, ui, repo, *pats, **opts):
if opts.get(r'sparse'): if opts.get('sparse'):
dirs = set() dirs = set()
for pat in pats: for pat in pats:
dirname, basename = util.split(pat) dirname, basename = util.split(pat)
dirs.add(dirname) dirs.add(dirname)
sparse.updateconfig(repo, list(dirs), opts, include=True) sparse.updateconfig(repo, list(dirs), opts, include=True)
return orig(ui, repo, *pats, **opts) return orig(ui, repo, *pats, **opts)
extensions.wrapcommand(commands.table, b'add', _add) extensions.wrapcommand(commands.table, b'add', _add)

hgext/transplant.py

) )
else: else:
parent = parents[0] parent = parents[0]
if skipmerge: if skipmerge:
patchfile = None patchfile = None
else: else:
fd, patchfile = pycompat.mkstemp(prefix=b'hg-transplant-') fd, patchfile = pycompat.mkstemp(prefix=b'hg-transplant-')
fp = os.fdopen(fd, r'wb') fp = os.fdopen(fd, 'wb')
gen = patch.diff(source, parent, node, opts=diffopts) gen = patch.diff(source, parent, node, opts=diffopts)
for chunk in gen: for chunk in gen:
fp.write(chunk) fp.write(chunk)
fp.close() fp.close()
del revmap[rev] del revmap[rev]
if patchfile or domerge: if patchfile or domerge:
try: try:
lock.release() lock.release()
def filter(self, filter, node, changelog, patchfile): def filter(self, filter, node, changelog, patchfile):
'''arbitrarily rewrite changeset before applying it''' '''arbitrarily rewrite changeset before applying it'''
self.ui.status(_(b'filtering %s\n') % patchfile) self.ui.status(_(b'filtering %s\n') % patchfile)
user, date, msg = (changelog[1], changelog[2], changelog[4]) user, date, msg = (changelog[1], changelog[2], changelog[4])
fd, headerfile = pycompat.mkstemp(prefix=b'hg-transplant-') fd, headerfile = pycompat.mkstemp(prefix=b'hg-transplant-')
fp = os.fdopen(fd, r'wb') fp = os.fdopen(fd, 'wb')
fp.write(b"# HG changeset patch\n") fp.write(b"# HG changeset patch\n")
fp.write(b"# User %s\n" % user) fp.write(b"# User %s\n" % user)
fp.write(b"# Date %d %d\n" % date) fp.write(b"# Date %d %d\n" % date)
fp.write(msg + b'\n') fp.write(msg + b'\n')
fp.close() fp.close()
try: try:
self.ui.system( self.ui.system(

hgext/zeroconf/Zeroconf.py

while True: while True:
len = ord(self.data[off : off + 1]) len = ord(self.data[off : off + 1])
off += 1 off += 1
if len == 0: if len == 0:
break break
t = len & 0xC0 t = len & 0xC0
if t == 0x00: if t == 0x00:
result = r''.join((result, self.readUTF(off, len) + r'.')) result = ''.join((result, self.readUTF(off, len) + '.'))
off += len off += len
elif t == 0xC0: elif t == 0xC0:
if next < 0: if next < 0:
next = off + 1 next = off + 1
off = ((len & 0x3F) << 8) | ord(self.data[off : off + 1]) off = ((len & 0x3F) << 8) | ord(self.data[off : off + 1])
if off >= first: if off >= first:
raise BadDomainNameCircular(off) raise BadDomainNameCircular(off)
first = off first = off
self.socket.bind(self.group) self.socket.bind(self.group)
except Exception: except Exception:
# Some versions of linux raise an exception even though # Some versions of linux raise an exception even though
# SO_REUSEADDR and SO_REUSEPORT have been set, so ignore it # SO_REUSEADDR and SO_REUSEPORT have been set, so ignore it
pass pass
self.socket.setsockopt( self.socket.setsockopt(
socket.SOL_IP, socket.SOL_IP,
socket.IP_ADD_MEMBERSHIP, socket.IP_ADD_MEMBERSHIP,
socket.inet_aton(_MDNS_ADDR) + socket.inet_aton(r'0.0.0.0'), socket.inet_aton(_MDNS_ADDR) + socket.inet_aton('0.0.0.0'),
) )
self.listeners = [] self.listeners = []
self.browsers = [] self.browsers = []
self.services = {} self.services = {}
self.servicetypes = {} self.servicetypes = {}
self.cache = DNSCache() self.cache = DNSCache()
if globals()[b'_GLOBAL_DONE'] == 0: if globals()[b'_GLOBAL_DONE'] == 0:
globals()[b'_GLOBAL_DONE'] = 1 globals()[b'_GLOBAL_DONE'] = 1
self.notifyAll() self.notifyAll()
self.engine.notify() self.engine.notify()
self.unregisterAllServices() self.unregisterAllServices()
self.socket.setsockopt( self.socket.setsockopt(
socket.SOL_IP, socket.SOL_IP,
socket.IP_DROP_MEMBERSHIP, socket.IP_DROP_MEMBERSHIP,
socket.inet_aton(_MDNS_ADDR) + socket.inet_aton(r'0.0.0.0'), socket.inet_aton(_MDNS_ADDR) + socket.inet_aton('0.0.0.0'),
) )
self.socket.close() self.socket.close()
# Test a few module features, including service registration, service # Test a few module features, including service registration, service
# query (for Zoe), and service unregistration. # query (for Zoe), and service unregistration.
if __name__ == '__main__': if __name__ == '__main__':

hgext/zeroconf/__init__.py

server = None server = None
localip = None localip = None
def getip(): def getip():
# finds external-facing interface without sending any packets (Linux) # finds external-facing interface without sending any packets (Linux)
try: try:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect((r'1.0.0.1', 0)) s.connect(('1.0.0.1', 0))
ip = s.getsockname()[0] ip = s.getsockname()[0]
return ip return ip
except socket.error: except socket.error:
pass pass
# Generic method, sometimes gives useless results # Generic method, sometimes gives useless results
try: try:
dumbip = socket.gethostbyaddr(socket.gethostname())[2][0] dumbip = socket.gethostbyaddr(socket.gethostname())[2][0]
if r':' in dumbip: if ':' in dumbip:
dumbip = r'127.0.0.1' dumbip = '127.0.0.1'
if not dumbip.startswith(r'127.'): if not dumbip.startswith('127.'):
return dumbip return dumbip
except (socket.gaierror, socket.herror): except (socket.gaierror, socket.herror):
dumbip = r'127.0.0.1' dumbip = '127.0.0.1'
# works elsewhere, but actually sends a packet # works elsewhere, but actually sends a packet
try: try:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect((r'1.0.0.1', 1)) s.connect(('1.0.0.1', 1))
ip = s.getsockname()[0] ip = s.getsockname()[0]
return ip return ip
except socket.error: except socket.error:
pass pass
return dumbip return dumbip
def publish(name, desc, path, port): def publish(name, desc, path, port):
global server, localip global server, localip
if not server: if not server:
ip = getip() ip = getip()
if ip.startswith(r'127.'): if ip.startswith('127.'):
# if we have no internet connection, this can happen. # if we have no internet connection, this can happen.
return return
localip = socket.inet_aton(ip) localip = socket.inet_aton(ip)
server = Zeroconf.Zeroconf(ip) server = Zeroconf.Zeroconf(ip)
hostname = socket.gethostname().split(r'.')[0] hostname = socket.gethostname().split('.')[0]
host = hostname + r".local" host = hostname + ".local"
name = "%s-%s" % (hostname, name) name = "%s-%s" % (hostname, name)
# advertise to browsers # advertise to browsers
svc = Zeroconf.ServiceInfo( svc = Zeroconf.ServiceInfo(
b'_http._tcp.local.', b'_http._tcp.local.',
pycompat.bytestr(name + r'._http._tcp.local.'), pycompat.bytestr(name + '._http._tcp.local.'),
server=host, server=host,
port=port, port=port,
properties={b'description': desc, b'path': b"/" + path}, properties={b'description': desc, b'path': b"/" + path},
address=localip, address=localip,
weight=0, weight=0,
priority=0, priority=0,
) )
server.registerService(svc) server.registerService(svc)
# advertise to Mercurial clients # advertise to Mercurial clients
svc = Zeroconf.ServiceInfo( svc = Zeroconf.ServiceInfo(
b'_hg._tcp.local.', b'_hg._tcp.local.',
pycompat.bytestr(name + r'._hg._tcp.local.'), pycompat.bytestr(name + '._hg._tcp.local.'),
server=host, server=host,
port=port, port=port,
properties={b'description': desc, b'path': b"/" + path}, properties={b'description': desc, b'path': b"/" + path},
address=localip, address=localip,
weight=0, weight=0,
priority=0, priority=0,
) )
server.registerService(svc) server.registerService(svc)
del self.found[repr(name)] del self.found[repr(name)]
def addService(self, server, type, name): def addService(self, server, type, name):
self.found[repr(name)] = server.getServiceInfo(type, name) self.found[repr(name)] = server.getServiceInfo(type, name)
def getzcpaths(): def getzcpaths():
ip = getip() ip = getip()
if ip.startswith(r'127.'): if ip.startswith('127.'):
return return
server = Zeroconf.Zeroconf(ip) server = Zeroconf.Zeroconf(ip)
l = listener() l = listener()
Zeroconf.ServiceBrowser(server, b"_hg._tcp.local.", l) Zeroconf.ServiceBrowser(server, b"_hg._tcp.local.", l)
time.sleep(1) time.sleep(1)
server.close() server.close()
for value in l.found.values(): for value in l.found.values():
name = value.name[: value.name.index(b'.')] name = value.name[: value.name.index(b'.')]

mercurial/ancestor.py

from .node import nullrev from .node import nullrev
from . import ( from . import (
dagop, dagop,
policy, policy,
pycompat, pycompat,
) )
parsers = policy.importmod(r'parsers') parsers = policy.importmod('parsers')
def commonancestorsheads(pfunc, *nodes): def commonancestorsheads(pfunc, *nodes):
"""Returns a set with the heads of all common ancestors of all nodes, """Returns a set with the heads of all common ancestors of all nodes,
heads(::nodes[0] and ::nodes[1] and ...) . heads(::nodes[0] and ::nodes[1] and ...) .
pfunc must return a list of parent vertices for a given vertex. pfunc must return a list of parent vertices for a given vertex.
""" """

mercurial/archival.py

class tarit(object): class tarit(object):
'''write archive to tar file or stream. can write uncompressed, '''write archive to tar file or stream. can write uncompressed,
or compress with gzip or bzip2.''' or compress with gzip or bzip2.'''
class GzipFileWithTime(gzip.GzipFile): class GzipFileWithTime(gzip.GzipFile):
def __init__(self, *args, **kw): def __init__(self, *args, **kw):
timestamp = None timestamp = None
if r'timestamp' in kw: if 'timestamp' in kw:
timestamp = kw.pop(r'timestamp') timestamp = kw.pop('timestamp')
if timestamp is None: if timestamp is None:
self.timestamp = time.time() self.timestamp = time.time()
else: else:
self.timestamp = timestamp self.timestamp = timestamp
gzip.GzipFile.__init__(self, *args, **kw) gzip.GzipFile.__init__(self, *args, **kw)
def _write_gzip_header(self): def _write_gzip_header(self):
self.fileobj.write(b'\037\213') # magic header self.fileobj.write(b'\037\213') # magic header
class zipit(object): class zipit(object):
'''write archive to zip file or stream. can write uncompressed, '''write archive to zip file or stream. can write uncompressed,
or compressed with deflate.''' or compressed with deflate.'''
def __init__(self, dest, mtime, compress=True): def __init__(self, dest, mtime, compress=True):
if isinstance(dest, bytes): if isinstance(dest, bytes):
dest = pycompat.fsdecode(dest) dest = pycompat.fsdecode(dest)
self.z = zipfile.ZipFile( self.z = zipfile.ZipFile(
dest, r'w', compress and zipfile.ZIP_DEFLATED or zipfile.ZIP_STORED dest, 'w', compress and zipfile.ZIP_DEFLATED or zipfile.ZIP_STORED
) )
# Python's zipfile module emits deprecation warnings if we try # Python's zipfile module emits deprecation warnings if we try
# to store files with a date before 1980. # to store files with a date before 1980.
epoch = 315532800 # calendar.timegm((1980, 1, 1, 0, 0, 0, 1, 1, 0)) epoch = 315532800 # calendar.timegm((1980, 1, 1, 0, 0, 0, 1, 1, 0))
if mtime < epoch: if mtime < epoch:
mtime = epoch mtime = epoch

mercurial/branchmap.py

def clear(self): def clear(self):
self._per_filter.clear() self._per_filter.clear()
def _unknownnode(node): def _unknownnode(node):
""" raises ValueError when branchcache found a node which does not exists """ raises ValueError when branchcache found a node which does not exists
""" """
raise ValueError(r'node %s does not exist' % pycompat.sysstr(hex(node))) raise ValueError('node %s does not exist' % pycompat.sysstr(hex(node)))
def _branchcachedesc(repo): def _branchcachedesc(repo):
if repo.filtername is not None: if repo.filtername is not None:
return b'branch cache (%s)' % repo.filtername return b'branch cache (%s)' % repo.filtername
else: else:
return b'branch cache' return b'branch cache'
bcache = cls( bcache = cls(
tipnode=last, tipnode=last,
tiprev=lrev, tiprev=lrev,
filteredhash=filteredhash, filteredhash=filteredhash,
hasnode=hasnode, hasnode=hasnode,
) )
if not bcache.validfor(repo): if not bcache.validfor(repo):
# invalidate the cache # invalidate the cache
raise ValueError(r'tip differs') raise ValueError('tip differs')
bcache.load(repo, lineiter) bcache.load(repo, lineiter)
except (IOError, OSError): except (IOError, OSError):
return None return None
except Exception as inst: except Exception as inst:
if repo.ui.debugflag: if repo.ui.debugflag:
msg = b'invalid %s: %s\n' msg = b'invalid %s: %s\n'
repo.ui.debug( repo.ui.debug(
""" fully loads the branchcache by reading from the file using the line """ fully loads the branchcache by reading from the file using the line
iterator passed""" iterator passed"""
for line in lineiter: for line in lineiter:
line = line.rstrip(b'\n') line = line.rstrip(b'\n')
if not line: if not line:
continue continue
node, state, label = line.split(b" ", 2) node, state, label = line.split(b" ", 2)
if state not in b'oc': if state not in b'oc':
raise ValueError(r'invalid branch state') raise ValueError('invalid branch state')
label = encoding.tolocal(label.strip()) label = encoding.tolocal(label.strip())
node = bin(node) node = bin(node)
self._entries.setdefault(label, []).append(node) self._entries.setdefault(label, []).append(node)
if state == b'c': if state == b'c':
self._closednodes.add(node) self._closednodes.add(node)
@staticmethod @staticmethod
def _filename(repo): def _filename(repo):
branchidx |= _rbccloseflag branchidx |= _rbccloseflag
self._setcachedata(rev, node, branchidx) self._setcachedata(rev, node, branchidx)
# If no cache data were readable (non exists, bad permission, etc) # If no cache data were readable (non exists, bad permission, etc)
# the cache was bypassing itself by setting: # the cache was bypassing itself by setting:
# #
# self.branchinfo = self._branchinfo # self.branchinfo = self._branchinfo
# #
# Since we now have data in the cache, we need to drop this bypassing. # Since we now have data in the cache, we need to drop this bypassing.
if r'branchinfo' in vars(self): if 'branchinfo' in vars(self):
del self.branchinfo del self.branchinfo
def _setcachedata(self, rev, node, branchidx): def _setcachedata(self, rev, node, branchidx):
"""Writes the node's branch data to the in-memory cache data.""" """Writes the node's branch data to the in-memory cache data."""
if rev == nullrev: if rev == nullrev:
return return
rbcrevidx = rev * _rbcrecsize rbcrevidx = rev * _rbcrecsize
if len(self._rbcrevs) < rbcrevidx + _rbcrecsize: if len(self._rbcrevs) < rbcrevidx + _rbcrecsize:

mercurial/bundle2.py

Parameter starting with a lower case letter are advisory and will be Parameter starting with a lower case letter are advisory and will be
ignored when unknown. Those starting with an upper case letter are ignored when unknown. Those starting with an upper case letter are
mandatory and will this function will raise a KeyError when unknown. mandatory and will this function will raise a KeyError when unknown.
Note: no option are currently supported. Any input will be either Note: no option are currently supported. Any input will be either
ignored or failing. ignored or failing.
""" """
if not name: if not name:
raise ValueError(r'empty parameter name') raise ValueError('empty parameter name')
if name[0:1] not in pycompat.bytestr( if name[0:1] not in pycompat.bytestr(
string.ascii_letters # pytype: disable=wrong-arg-types string.ascii_letters # pytype: disable=wrong-arg-types
): ):
raise ValueError(r'non letter first character: %s' % name) raise ValueError('non letter first character: %s' % name)
try: try:
handler = b2streamparamsmap[name.lower()] handler = b2streamparamsmap[name.lower()]
except KeyError: except KeyError:
if name[0:1].islower(): if name[0:1].islower():
indebug(self.ui, b"ignoring unknown parameter %s" % name) indebug(self.ui, b"ignoring unknown parameter %s" % name)
else: else:
raise error.BundleUnknownFeatureError(params=(name,)) raise error.BundleUnknownFeatureError(params=(name,))
else: else:
for key, value in advpar: for key, value in advpar:
header.append(key) header.append(key)
header.append(value) header.append(value)
## finalize header ## finalize header
try: try:
headerchunk = b''.join(header) headerchunk = b''.join(header)
except TypeError: except TypeError:
raise TypeError( raise TypeError(
r'Found a non-bytes trying to ' 'Found a non-bytes trying to '
r'build bundle part header: %r' % header 'build bundle part header: %r' % header
) )
outdebug(ui, b'header chunk size: %i' % len(headerchunk)) outdebug(ui, b'header chunk size: %i' % len(headerchunk))
yield _pack(_fpartheadersize, len(headerchunk)) yield _pack(_fpartheadersize, len(headerchunk))
yield headerchunk yield headerchunk
## payload ## payload
try: try:
for chunk in self._payloadchunks(): for chunk in self._payloadchunks():
outdebug(ui, b'payload chunk size: %i' % len(chunk)) outdebug(ui, b'payload chunk size: %i' % len(chunk))
def _formatrequirementsparams(requirements): def _formatrequirementsparams(requirements):
requirements = _formatrequirementsspec(requirements) requirements = _formatrequirementsspec(requirements)
params = b"%s%s" % (urlreq.quote(b"requirements="), requirements) params = b"%s%s" % (urlreq.quote(b"requirements="), requirements)
return params return params
def addpartbundlestream2(bundler, repo, **kwargs): def addpartbundlestream2(bundler, repo, **kwargs):
if not kwargs.get(r'stream', False): if not kwargs.get('stream', False):
return return
if not streamclone.allowservergeneration(repo): if not streamclone.allowservergeneration(repo):
raise error.Abort( raise error.Abort(
_( _(
b'stream data requested but server does not allow ' b'stream data requested but server does not allow '
b'this feature' b'this feature'
), ),
hint=_( hint=_(
b'well-behaved clients should not be ' b'well-behaved clients should not be '
b'requesting stream data from servers not ' b'requesting stream data from servers not '
b'advertising it; the client may be buggy' b'advertising it; the client may be buggy'
), ),
) )
# Stream clones don't compress well. And compression undermines a # Stream clones don't compress well. And compression undermines a
# goal of stream clones, which is to be fast. Communicate the desire # goal of stream clones, which is to be fast. Communicate the desire
# to avoid compression to consumers of the bundle. # to avoid compression to consumers of the bundle.
bundler.prefercompressed = False bundler.prefercompressed = False
# get the includes and excludes # get the includes and excludes
includepats = kwargs.get(r'includepats') includepats = kwargs.get('includepats')
excludepats = kwargs.get(r'excludepats') excludepats = kwargs.get('excludepats')
narrowstream = repo.ui.configbool( narrowstream = repo.ui.configbool(
b'experimental', b'server.stream-narrow-clones' b'experimental', b'server.stream-narrow-clones'
) )
if (includepats or excludepats) and not narrowstream: if (includepats or excludepats) and not narrowstream:
raise error.Abort(_(b'server does not support narrow stream clones')) raise error.Abort(_(b'server does not support narrow stream clones'))
if reposidedata and not bundlesidedata: if reposidedata and not bundlesidedata:
msg = b"repository is using sidedata but the bundle source do not" msg = b"repository is using sidedata but the bundle source do not"
hint = b'this is currently unsupported' hint = b'this is currently unsupported'
raise error.Abort(msg, hint=hint) raise error.Abort(msg, hint=hint)
extrakwargs = {} extrakwargs = {}
targetphase = inpart.params.get(b'targetphase') targetphase = inpart.params.get(b'targetphase')
if targetphase is not None: if targetphase is not None:
extrakwargs[r'targetphase'] = int(targetphase) extrakwargs['targetphase'] = int(targetphase)
ret = _processchangegroup( ret = _processchangegroup(
op, op,
cg, cg,
tr, tr,
b'bundle2', b'bundle2',
b'bundle2', b'bundle2',
expectedtotal=nbchangesets, expectedtotal=nbchangesets,
**extrakwargs **extrakwargs

mercurial/bundlerepo.py

self._cgunpacker = changegroup.getunbundler(version, cgstream, b'UN') self._cgunpacker = changegroup.getunbundler(version, cgstream, b'UN')
def _writetempbundle(self, readfn, suffix, header=b''): def _writetempbundle(self, readfn, suffix, header=b''):
"""Write a temporary file to disk """Write a temporary file to disk
""" """
fdtemp, temp = self.vfs.mkstemp(prefix=b"hg-bundle-", suffix=suffix) fdtemp, temp = self.vfs.mkstemp(prefix=b"hg-bundle-", suffix=suffix)
self.tempfile = temp self.tempfile = temp
with os.fdopen(fdtemp, r'wb') as fptemp: with os.fdopen(fdtemp, 'wb') as fptemp:
fptemp.write(header) fptemp.write(header)
while True: while True:
chunk = readfn(2 ** 18) chunk = readfn(2 ** 18)
if not chunk: if not chunk:
break break
fptemp.write(chunk) fptemp.write(chunk)
return self.vfs.open(self.tempfile, mode=b"rb") return self.vfs.open(self.tempfile, mode=b"rb")
@localrepo.unfilteredpropertycache @localrepo.unfilteredpropertycache
def filestart(self): def filestart(self):
self.manifestlog self.manifestlog
# If filestart was not set by self.manifestlog, that means the # If filestart was not set by self.manifestlog, that means the
# manifestlog implementation did not consume the manifests from the # manifestlog implementation did not consume the manifests from the
# changegroup (ex: it might be consuming trees from a separate bundle2 # changegroup (ex: it might be consuming trees from a separate bundle2
# part instead). So we need to manually consume it. # part instead). So we need to manually consume it.
if r'filestart' not in self.__dict__: if 'filestart' not in self.__dict__:
self._consumemanifest() self._consumemanifest()
return self.filestart return self.filestart
def url(self): def url(self):
return self._url return self._url
def file(self, f): def file(self, f):

mercurial/changelog.py

"""Holds results of a parsed changelog revision. """Holds results of a parsed changelog revision.
Changelog revisions consist of multiple pieces of data, including Changelog revisions consist of multiple pieces of data, including
the manifest node, user, and date. This object exposes a view into the manifest node, user, and date. This object exposes a view into
the parsed object. the parsed object.
""" """
__slots__ = ( __slots__ = (
r'_offsets', '_offsets',
r'_text', '_text',
r'_sidedata', '_sidedata',
r'_cpsd', '_cpsd',
) )
def __new__(cls, text, sidedata, cpsd): def __new__(cls, text, sidedata, cpsd):
if not text: if not text:
return _changelogrevision(extra=_defaultextra) return _changelogrevision(extra=_defaultextra)
self = super(changelogrevision, cls).__new__(cls) self = super(changelogrevision, cls).__new__(cls)
# We could return here and implement the following as an __init__. # We could return here and implement the following as an __init__.

mercurial/chgserver.py

else: else:
raise error.Abort(_(b'unexpected command: %s') % cmd) raise error.Abort(_(b'unexpected command: %s') % cmd)
else: else:
raise error.ProgrammingError(b'invalid S channel type: %s' % type) raise error.ProgrammingError(b'invalid S channel type: %s' % type)
_iochannels = [ _iochannels = [
# server.ch, ui.fp, mode # server.ch, ui.fp, mode
(b'cin', b'fin', r'rb'), (b'cin', b'fin', 'rb'),
(b'cout', b'fout', r'wb'), (b'cout', b'fout', 'wb'),
(b'cerr', b'ferr', r'wb'), (b'cerr', b'ferr', 'wb'),
] ]
class chgcmdserver(commandserver.server): class chgcmdserver(commandserver.server):
def __init__( def __init__(
self, ui, repo, fin, fout, sock, prereposetups, hashstate, baseaddress self, ui, repo, fin, fout, sock, prereposetups, hashstate, baseaddress
): ):
super(chgcmdserver, self).__init__( super(chgcmdserver, self).__init__(

mercurial/cmdutil.py

def parsealiases(cmd): def parsealiases(cmd):
return cmd.split(b"|") return cmd.split(b"|")
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
def wrapwrite(orig, *args, **kw): def wrapwrite(orig, *args, **kw):
label = kw.pop(r'label', b'') label = kw.pop('label', b'')
for chunk, l in patch.difflabel(lambda: args): for chunk, l in patch.difflabel(lambda: args):
orig(chunk, label=label + l) orig(chunk, label=label + l)
oldwrite = ui.write oldwrite = ui.write
def wrap(*args, **kwargs): def wrap(*args, **kwargs):
return wrapwrite(oldwrite, *args, **kwargs) return wrapwrite(oldwrite, *args, **kwargs)
) )
for subpath in sorted(wctx.substate): for subpath in sorted(wctx.substate):
sub = wctx.sub(subpath) sub = wctx.sub(subpath)
try: try:
submatch = matchmod.subdirmatcher(subpath, match) submatch = matchmod.subdirmatcher(subpath, match)
subprefix = repo.wvfs.reljoin(prefix, subpath) subprefix = repo.wvfs.reljoin(prefix, subpath)
subuipathfn = scmutil.subdiruipathfn(subpath, uipathfn) subuipathfn = scmutil.subdiruipathfn(subpath, uipathfn)
if opts.get(r'subrepos'): if opts.get('subrepos'):
bad.extend( bad.extend(
sub.add(ui, submatch, subprefix, subuipathfn, False, **opts) sub.add(ui, submatch, subprefix, subuipathfn, False, **opts)
) )
else: else:
bad.extend( bad.extend(
sub.add(ui, submatch, subprefix, subuipathfn, True, **opts) sub.add(ui, submatch, subprefix, subuipathfn, True, **opts)
) )
except error.LookupError: except error.LookupError:
ui.status( ui.status(
_(b"skipping missing subrepository: %s\n") % uipathfn(subpath) _(b"skipping missing subrepository: %s\n") % uipathfn(subpath)
) )
if not opts.get(r'dry_run'): if not opts.get('dry_run'):
rejected = wctx.add(names, prefix) rejected = wctx.add(names, prefix)
bad.extend(f for f in rejected if f in match.files()) bad.extend(f for f in rejected if f in match.files())
return bad return bad
def addwebdirpath(repo, serverpath, webconf): def addwebdirpath(repo, serverpath, webconf):
webconf[serverpath] = repo.root webconf[serverpath] = repo.root
repo.ui.debug(b'adding %s = %s\n' % (serverpath, repo.root)) repo.ui.debug(b'adding %s = %s\n' % (serverpath, repo.root))

mercurial/color.py

for key, (b, e, c) in ui._terminfoparams.copy().items(): for key, (b, e, c) in ui._terminfoparams.copy().items():
if not b: if not b:
continue continue
if not c and not curses.tigetstr(pycompat.sysstr(e)): if not c and not curses.tigetstr(pycompat.sysstr(e)):
# Most terminals don't support dim, invis, etc, so don't be # Most terminals don't support dim, invis, etc, so don't be
# noisy and use ui.debug(). # noisy and use ui.debug().
ui.debug(b"no terminfo entry for %s\n" % e) ui.debug(b"no terminfo entry for %s\n" % e)
del ui._terminfoparams[key] del ui._terminfoparams[key]
if not curses.tigetstr(r'setaf') or not curses.tigetstr(r'setab'): if not curses.tigetstr('setaf') or not curses.tigetstr('setab'):
# Only warn about missing terminfo entries if we explicitly asked for # Only warn about missing terminfo entries if we explicitly asked for
# terminfo mode and we're in a formatted terminal. # terminfo mode and we're in a formatted terminal.
if mode == b"terminfo" and formatted: if mode == b"terminfo" and formatted:
ui.warn( ui.warn(
_( _(
b"no terminfo entry for setab/setaf: reverting to " b"no terminfo entry for setab/setaf: reverting to "
b"ECMA-48 color\n" b"ECMA-48 color\n"
) )
except KeyError: except KeyError:
return b'' return b''
if attr: if attr:
if termcode: if termcode:
return termcode return termcode
else: else:
return curses.tigetstr(pycompat.sysstr(val)) return curses.tigetstr(pycompat.sysstr(val))
elif bg: elif bg:
return curses.tparm(curses.tigetstr(r'setab'), val) return curses.tparm(curses.tigetstr('setab'), val)
else: else:
return curses.tparm(curses.tigetstr(r'setaf'), val) return curses.tparm(curses.tigetstr('setaf'), val)
def _mergeeffects(text, start, stop): def _mergeeffects(text, start, stop):
"""Insert start sequence at every occurrence of stop sequence """Insert start sequence at every occurrence of stop sequence
>>> s = _mergeeffects(b'cyan', b'[C]', b'|') >>> s = _mergeeffects(b'cyan', b'[C]', b'|')
>>> s = _mergeeffects(s + b'yellow', b'[Y]', b'|') >>> s = _mergeeffects(s + b'yellow', b'[Y]', b'|')
>>> s = _mergeeffects(b'ma' + s + b'genta', b'[M]', b'|') >>> s = _mergeeffects(b'ma' + s + b'genta', b'[M]', b'|')
_kernel32 = ctypes.windll.kernel32 _kernel32 = ctypes.windll.kernel32
_WORD = ctypes.c_ushort _WORD = ctypes.c_ushort
_INVALID_HANDLE_VALUE = -1 _INVALID_HANDLE_VALUE = -1
class _COORD(ctypes.Structure): class _COORD(ctypes.Structure):
_fields_ = [(r'X', ctypes.c_short), (r'Y', ctypes.c_short)] _fields_ = [('X', ctypes.c_short), ('Y', ctypes.c_short)]
class _SMALL_RECT(ctypes.Structure): class _SMALL_RECT(ctypes.Structure):
_fields_ = [ _fields_ = [
(r'Left', ctypes.c_short), ('Left', ctypes.c_short),
(r'Top', ctypes.c_short), ('Top', ctypes.c_short),
(r'Right', ctypes.c_short), ('Right', ctypes.c_short),
(r'Bottom', ctypes.c_short), ('Bottom', ctypes.c_short),
] ]
class _CONSOLE_SCREEN_BUFFER_INFO(ctypes.Structure): class _CONSOLE_SCREEN_BUFFER_INFO(ctypes.Structure):
_fields_ = [ _fields_ = [
(r'dwSize', _COORD), ('dwSize', _COORD),
(r'dwCursorPosition', _COORD), ('dwCursorPosition', _COORD),
(r'wAttributes', _WORD), ('wAttributes', _WORD),
(r'srWindow', _SMALL_RECT), ('srWindow', _SMALL_RECT),
(r'dwMaximumWindowSize', _COORD), ('dwMaximumWindowSize', _COORD),
] ]
_STD_OUTPUT_HANDLE = 0xFFFFFFF5 # (DWORD)-11 _STD_OUTPUT_HANDLE = 0xFFFFFFF5 # (DWORD)-11
_STD_ERROR_HANDLE = 0xFFFFFFF4 # (DWORD)-12 _STD_ERROR_HANDLE = 0xFFFFFFF4 # (DWORD)-12
_FOREGROUND_BLUE = 0x0001 _FOREGROUND_BLUE = 0x0001
_FOREGROUND_GREEN = 0x0002 _FOREGROUND_GREEN = 0x0002
_FOREGROUND_RED = 0x0004 _FOREGROUND_RED = 0x0004
w32effects = None w32effects = None
else: else:
origattr = csbi.wAttributes origattr = csbi.wAttributes
ansire = re.compile( ansire = re.compile(
br'\033\[([^m]*)m([^\033]*)(.*)', re.MULTILINE | re.DOTALL br'\033\[([^m]*)m([^\033]*)(.*)', re.MULTILINE | re.DOTALL
) )
def win32print(ui, writefunc, text, **opts): def win32print(ui, writefunc, text, **opts):
label = opts.get(r'label', b'') label = opts.get('label', b'')
attr = origattr attr = origattr
def mapcolor(val, attr): def mapcolor(val, attr):
if val == -1: if val == -1:
return origattr return origattr
elif val in passthrough: elif val in passthrough:
return attr | val return attr | val
elif val > 0x0F: elif val > 0x0F:

mercurial/commands.py

def abort(ui, repo, **opts): def abort(ui, repo, **opts):
"""abort an unfinished operation (EXPERIMENTAL) """abort an unfinished operation (EXPERIMENTAL)
Aborts a multistep operation like graft, histedit, rebase, merge, Aborts a multistep operation like graft, histedit, rebase, merge,
and unshelve if they are in an unfinished state. and unshelve if they are in an unfinished state.
use --dry-run/-n to dry run the command. use --dry-run/-n to dry run the command.
""" """
dryrun = opts.get(r'dry_run') dryrun = opts.get('dry_run')
abortstate = cmdutil.getunfinishedstate(repo) abortstate = cmdutil.getunfinishedstate(repo)
if not abortstate: if not abortstate:
raise error.Abort(_(b'no operation in progress')) raise error.Abort(_(b'no operation in progress'))
if not abortstate.abortfunc: if not abortstate.abortfunc:
raise error.Abort( raise error.Abort(
( (
_(b"%s in progress but does not support 'hg abort'") _(b"%s in progress but does not support 'hg abort'")
% (abortstate._opname) % (abortstate._opname)
hg commit --amend --date now hg commit --amend --date now
""" """
with repo.wlock(), repo.lock(): with repo.wlock(), repo.lock():
return _docommit(ui, repo, *pats, **opts) return _docommit(ui, repo, *pats, **opts)
def _docommit(ui, repo, *pats, **opts): def _docommit(ui, repo, *pats, **opts):
if opts.get(r'interactive'): if opts.get('interactive'):
opts.pop(r'interactive') opts.pop('interactive')
ret = cmdutil.dorecord( ret = cmdutil.dorecord(
ui, repo, commit, None, False, cmdutil.recordfilter, *pats, **opts ui, repo, commit, None, False, cmdutil.recordfilter, *pats, **opts
) )
# ret can be 0 (no changes to record) or the value returned by # ret can be 0 (no changes to record) or the value returned by
# commit(), 1 if nothing changed or None on success. # commit(), 1 if nothing changed or None on success.
return 1 if ret == 0 else ret return 1 if ret == 0 else ret
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
def continuecmd(ui, repo, **opts): def continuecmd(ui, repo, **opts):
"""resumes an interrupted operation (EXPERIMENTAL) """resumes an interrupted operation (EXPERIMENTAL)
Finishes a multistep operation like graft, histedit, rebase, merge, Finishes a multistep operation like graft, histedit, rebase, merge,
and unshelve if they are in an interrupted state. and unshelve if they are in an interrupted state.
use --dry-run/-n to dry run the command. use --dry-run/-n to dry run the command.
""" """
dryrun = opts.get(r'dry_run') dryrun = opts.get('dry_run')
contstate = cmdutil.getunfinishedstate(repo) contstate = cmdutil.getunfinishedstate(repo)
if not contstate: if not contstate:
raise error.Abort(_(b'no operation in progress')) raise error.Abort(_(b'no operation in progress'))
if not contstate.continuefunc: if not contstate.continuefunc:
raise error.Abort( raise error.Abort(
( (
_(b"%s in progress but does not support 'hg continue'") _(b"%s in progress but does not support 'hg continue'")
% (contstate._opname) % (contstate._opname)
[(b'o', b'options', None, _(b'show the command options'))], [(b'o', b'options', None, _(b'show the command options'))],
_(b'[-o] CMD'), _(b'[-o] CMD'),
helpcategory=command.CATEGORY_HELP, helpcategory=command.CATEGORY_HELP,
norepo=True, norepo=True,
) )
def debugcomplete(ui, cmd=b'', **opts): def debugcomplete(ui, cmd=b'', **opts):
"""returns the completion list associated with the given command""" """returns the completion list associated with the given command"""
if opts.get(r'options'): if opts.get('options'):
options = [] options = []
otables = [globalopts] otables = [globalopts]
if cmd: if cmd:
aliases, entry = cmdutil.findcmd(cmd, table, False) aliases, entry = cmdutil.findcmd(cmd, table, False)
otables.append(entry[1]) otables.append(entry[1])
for t in otables: for t in otables:
for o in t: for o in t:
if b"(DEPRECATED)" in o[3]: if b"(DEPRECATED)" in o[3]:
m = matches[rev][fn] m = matches[rev][fn]
for lnum, cstart, cend, line in matchlines(body): for lnum, cstart, cend, line in matchlines(body):
s = linestate(line, lnum, cstart, cend) s = linestate(line, lnum, cstart, cend)
m.append(s) m.append(s)
def difflinestates(a, b): def difflinestates(a, b):
sm = difflib.SequenceMatcher(None, a, b) sm = difflib.SequenceMatcher(None, a, b)
for tag, alo, ahi, blo, bhi in sm.get_opcodes(): for tag, alo, ahi, blo, bhi in sm.get_opcodes():
if tag == r'insert': if tag == 'insert':
for i in pycompat.xrange(blo, bhi): for i in pycompat.xrange(blo, bhi):
yield (b'+', b[i]) yield (b'+', b[i])
elif tag == r'delete': elif tag == 'delete':
for i in pycompat.xrange(alo, ahi): for i in pycompat.xrange(alo, ahi):
yield (b'-', a[i]) yield (b'-', a[i])
elif tag == r'replace': elif tag == 'replace':
for i in pycompat.xrange(alo, ahi): for i in pycompat.xrange(alo, ahi):
yield (b'-', a[i]) yield (b'-', a[i])
for i in pycompat.xrange(blo, bhi): for i in pycompat.xrange(blo, bhi):
yield (b'+', b[i]) yield (b'+', b[i])
uipathfn = scmutil.getuipathfn(repo) uipathfn = scmutil.getuipathfn(repo)
def display(fm, fn, ctx, pstates, states): def display(fm, fn, ctx, pstates, states):
With no arguments, print a list of commands with short help messages. With no arguments, print a list of commands with short help messages.
Given a topic, extension, or command name, print help for that Given a topic, extension, or command name, print help for that
topic. topic.
Returns 0 if successful. Returns 0 if successful.
""" """
keep = opts.get(r'system') or [] keep = opts.get('system') or []
if len(keep) == 0: if len(keep) == 0:
if pycompat.sysplatform.startswith(b'win'): if pycompat.sysplatform.startswith(b'win'):
keep.append(b'windows') keep.append(b'windows')
elif pycompat.sysplatform == b'OpenVMS': elif pycompat.sysplatform == b'OpenVMS':
keep.append(b'vms') keep.append(b'vms')
elif pycompat.sysplatform == b'plan9': elif pycompat.sysplatform == b'plan9':
keep.append(b'plan9') keep.append(b'plan9')
else: else:
This command tries to fix the repository status after an This command tries to fix the repository status after an
interrupted operation. It should only be necessary when Mercurial interrupted operation. It should only be necessary when Mercurial
suggests it. suggests it.
Returns 0 if successful, 1 if nothing to recover or verify fails. Returns 0 if successful, 1 if nothing to recover or verify fails.
""" """
ret = repo.recover() ret = repo.recover()
if ret: if ret:
if opts[r'verify']: if opts['verify']:
return hg.verify(repo) return hg.verify(repo)
else: else:
msg = _( msg = _(
b"(verify step skipped, run `hg verify` to check your " b"(verify step skipped, run `hg verify` to check your "
b"repository content)\n" b"repository content)\n"
) )
ui.warn(msg) ui.warn(msg)
return 0 return 0
Returns 0 on success, 1 if no rollback data is available. Returns 0 on success, 1 if no rollback data is available.
""" """
if not ui.configbool(b'ui', b'rollback'): if not ui.configbool(b'ui', b'rollback'):
raise error.Abort( raise error.Abort(
_(b'rollback is disabled because it is unsafe'), _(b'rollback is disabled because it is unsafe'),
hint=b'see `hg help -v rollback` for information', hint=b'see `hg help -v rollback` for information',
) )
return repo.rollback(dryrun=opts.get(r'dry_run'), force=opts.get(r'force')) return repo.rollback(dryrun=opts.get('dry_run'), force=opts.get('force'))
@command( @command(
b'root', b'root',
[] + formatteropts, [] + formatteropts,
intents={INTENT_READONLY}, intents={INTENT_READONLY},
helpcategory=command.CATEGORY_WORKING_DIRECTORY, helpcategory=command.CATEGORY_WORKING_DIRECTORY,
) )
hint=_( hint=_(
b"see https://mercurial-scm.org/" b"see https://mercurial-scm.org/"
b"wiki/BundleFeature for more " b"wiki/BundleFeature for more "
b"information" b"information"
), ),
) )
modheads = bundle2.combinechangegroupresults(op) modheads = bundle2.combinechangegroupresults(op)
return postincoming(ui, repo, modheads, opts.get(r'update'), None, None) return postincoming(ui, repo, modheads, opts.get('update'), None, None)
@command( @command(
b'unshelve', b'unshelve',
[ [
(b'a', b'abort', None, _(b'abort an incomplete unshelve operation')), (b'a', b'abort', None, _(b'abort an incomplete unshelve operation')),
( (
b'c', b'c',
If you want to revert just one file to an older revision, use If you want to revert just one file to an older revision, use
:hg:`revert [-r REV] NAME`. :hg:`revert [-r REV] NAME`.
See :hg:`help dates` for a list of formats valid for -d/--date. See :hg:`help dates` for a list of formats valid for -d/--date.
Returns 0 on success, 1 if there are unresolved files. Returns 0 on success, 1 if there are unresolved files.
""" """
rev = opts.get(r'rev') rev = opts.get('rev')
date = opts.get(r'date') date = opts.get('date')
clean = opts.get(r'clean') clean = opts.get('clean')
check = opts.get(r'check') check = opts.get('check')
merge = opts.get(r'merge') merge = opts.get('merge')
if rev and node: if rev and node:
raise error.Abort(_(b"please specify just one revision")) raise error.Abort(_(b"please specify just one revision"))
if ui.configbool(b'commands', b'update.requiredest'): if ui.configbool(b'commands', b'update.requiredest'):
if not node and not rev and not date: if not node and not rev and not date:
raise error.Abort( raise error.Abort(
_(b'you must specify a destination'), _(b'you must specify a destination'),
hint=_(b'for example: hg update ".::"'), hint=_(b'for example: hg update ".::"'),
# if we defined a bookmark, we have to remember the original name # if we defined a bookmark, we have to remember the original name
brev = rev brev = rev
if rev: if rev:
repo = scmutil.unhidehashlikerevs(repo, [rev], b'nowarn') repo = scmutil.unhidehashlikerevs(repo, [rev], b'nowarn')
ctx = scmutil.revsingle(repo, rev, default=None) ctx = scmutil.revsingle(repo, rev, default=None)
rev = ctx.rev() rev = ctx.rev()
hidden = ctx.hidden() hidden = ctx.hidden()
overrides = {(b'ui', b'forcemerge'): opts.get(r'tool', b'')} overrides = {(b'ui', b'forcemerge'): opts.get('tool', b'')}
with ui.configoverride(overrides, b'update'): with ui.configoverride(overrides, b'update'):
ret = hg.updatetotally( ret = hg.updatetotally(
ui, repo, rev, brev, clean=clean, updatecheck=updatecheck ui, repo, rev, brev, clean=clean, updatecheck=updatecheck
) )
if hidden: if hidden:
ctxstr = ctx.hex()[:12] ctxstr = ctx.hex()[:12]
ui.warn(_(b"updated to hidden changeset %s\n") % ctxstr) ui.warn(_(b"updated to hidden changeset %s\n") % ctxstr)

mercurial/commandserver.py

def write(self, data): def write(self, data):
if not data: if not data:
return return
# single write() to guarantee the same atomicity as the underlying file # single write() to guarantee the same atomicity as the underlying file
self.out.write(struct.pack(b'>cI', self.channel, len(data)) + data) self.out.write(struct.pack(b'>cI', self.channel, len(data)) + data)
self.out.flush() self.out.flush()
def __getattr__(self, attr): def __getattr__(self, attr):
if attr in (r'isatty', r'fileno', r'tell', r'seek'): if attr in ('isatty', 'fileno', 'tell', 'seek'):
raise AttributeError(attr) raise AttributeError(attr)
return getattr(self.out, attr) return getattr(self.out, attr)
class channeledmessage(object): class channeledmessage(object):
""" """
Write encoded message and metadata to out in the following format: Write encoded message and metadata to out in the following format:
l = self.readline() l = self.readline()
if not l: if not l:
raise StopIteration raise StopIteration
return l return l
__next__ = next __next__ = next
def __getattr__(self, attr): def __getattr__(self, attr):
if attr in (r'isatty', r'fileno', r'tell', r'seek'): if attr in ('isatty', 'fileno', 'tell', 'seek'):
raise AttributeError(attr) raise AttributeError(attr)
return getattr(self.in_, attr) return getattr(self.in_, attr)
_messageencoders = { _messageencoders = {
b'cbor': lambda v: b''.join(cborutil.streamencode(v)), b'cbor': lambda v: b''.join(cborutil.streamencode(v)),
} }
# unrelated processes. # unrelated processes.
os.setpgid(0, 0) os.setpgid(0, 0)
# change random state otherwise forked request handlers would have a # change random state otherwise forked request handlers would have a
# same state inherited from parent. # same state inherited from parent.
random.seed() random.seed()
def _serverequest(ui, repo, conn, createcmdserver, prereposetups): def _serverequest(ui, repo, conn, createcmdserver, prereposetups):
fin = conn.makefile(r'rb') fin = conn.makefile('rb')
fout = conn.makefile(r'wb') fout = conn.makefile('wb')
sv = None sv = None
try: try:
sv = createcmdserver(repo, conn, fin, fout, prereposetups) sv = createcmdserver(repo, conn, fin, fout, prereposetups)
try: try:
sv.serve() sv.serve()
# handle exceptions that may be raised by command server. most of # handle exceptions that may be raised by command server. most of
# known exceptions are caught by dispatch. # known exceptions are caught by dispatch.
except error.Abort as inst: except error.Abort as inst:

mercurial/config.py

self._unset.append((section, name)) self._unset.append((section, name))
continue continue
raise error.ParseError(l.rstrip(), (b"%s:%d" % (src, line))) raise error.ParseError(l.rstrip(), (b"%s:%d" % (src, line)))
def read(self, path, fp=None, sections=None, remap=None): def read(self, path, fp=None, sections=None, remap=None):
if not fp: if not fp:
fp = util.posixfile(path, b'rb') fp = util.posixfile(path, b'rb')
assert getattr(fp, 'mode', r'rb') == r'rb', ( assert getattr(fp, 'mode', 'rb') == 'rb', (
b'config files must be opened in binary mode, got fp=%r mode=%r' b'config files must be opened in binary mode, got fp=%r mode=%r'
% (fp, fp.mode,) % (fp, fp.mode,)
) )
self.parse( self.parse(
path, fp.read(), sections=sections, remap=remap, include=self.read path, fp.read(), sections=sections, remap=remap, include=self.read
) )

mercurial/context.py

def p2(self): def p2(self):
parents = self._parents parents = self._parents
if len(parents) == 2: if len(parents) == 2:
return parents[1] return parents[1]
return self._repo[nullrev] return self._repo[nullrev]
def _fileinfo(self, path): def _fileinfo(self, path):
if r'_manifest' in self.__dict__: if '_manifest' in self.__dict__:
try: try:
return self._manifest[path], self._manifest.flags(path) return self._manifest[path], self._manifest.flags(path)
except KeyError: except KeyError:
raise error.ManifestLookupError( raise error.ManifestLookupError(
self._node, path, _(b'not found in manifest') self._node, path, _(b'not found in manifest')
) )
if r'_manifestdelta' in self.__dict__ or path in self.files(): if '_manifestdelta' in self.__dict__ or path in self.files():
if path in self._manifestdelta: if path in self._manifestdelta:
return ( return (
self._manifestdelta[path], self._manifestdelta[path],
self._manifestdelta.flags(path), self._manifestdelta.flags(path),
) )
mfl = self._repo.manifestlog mfl = self._repo.manifestlog
try: try:
node, flag = mfl[self._changeset.manifest].find(path) node, flag = mfl[self._changeset.manifest].find(path)
""" """
@propertycache @propertycache
def _filelog(self): def _filelog(self):
return self._repo.file(self._path) return self._repo.file(self._path)
@propertycache @propertycache
def _changeid(self): def _changeid(self):
if r'_changectx' in self.__dict__: if '_changectx' in self.__dict__:
return self._changectx.rev() return self._changectx.rev()
elif r'_descendantrev' in self.__dict__: elif '_descendantrev' in self.__dict__:
# this file context was created from a revision with a known # this file context was created from a revision with a known
# descendant, we can (lazily) correct for linkrev aliases # descendant, we can (lazily) correct for linkrev aliases
return self._adjustlinkrev(self._descendantrev) return self._adjustlinkrev(self._descendantrev)
else: else:
return self._filelog.linkrev(self._filerev) return self._filelog.linkrev(self._filerev)
@propertycache @propertycache
def _filenode(self): def _filenode(self):
if r'_fileid' in self.__dict__: if '_fileid' in self.__dict__:
return self._filelog.lookup(self._fileid) return self._filelog.lookup(self._fileid)
else: else:
return self._changectx.filenode(self._path) return self._changectx.filenode(self._path)
@propertycache @propertycache
def _filerev(self): def _filerev(self):
return self._filelog.rev(self._filenode) return self._filelog.rev(self._filenode)
iteration range in some internal usecase. iteration range in some internal usecase.
If `stoprev` is set, the `introrev` will not be searched past that If `stoprev` is set, the `introrev` will not be searched past that
`stoprev` revision and "None" might be returned. This is useful to `stoprev` revision and "None" might be returned. This is useful to
limit the iteration range. limit the iteration range.
""" """
toprev = None toprev = None
attrs = vars(self) attrs = vars(self)
if r'_changeid' in attrs: if '_changeid' in attrs:
# We have a cached value already # We have a cached value already
toprev = self._changeid toprev = self._changeid
elif r'_changectx' in attrs: elif '_changectx' in attrs:
# We know which changelog entry we are coming from # We know which changelog entry we are coming from
toprev = self._changectx.rev() toprev = self._changectx.rev()
if toprev is not None: if toprev is not None:
return self._adjustlinkrev(toprev, inclusive=True, stoprev=stoprev) return self._adjustlinkrev(toprev, inclusive=True, stoprev=stoprev)
elif r'_descendantrev' in attrs: elif '_descendantrev' in attrs:
introrev = self._adjustlinkrev(self._descendantrev, stoprev=stoprev) introrev = self._adjustlinkrev(self._descendantrev, stoprev=stoprev)
# be nice and cache the result of the computation # be nice and cache the result of the computation
if introrev is not None: if introrev is not None:
self._changeid = introrev self._changeid = introrev
return introrev return introrev
else: else:
return self.linkrev() return self.linkrev()
def introfilectx(self): def introfilectx(self):
"""Return filectx having identical contents, but pointing to the """Return filectx having identical contents, but pointing to the
changeset revision where this filectx was introduced""" changeset revision where this filectx was introduced"""
introrev = self.introrev() introrev = self.introrev()
if self.rev() == introrev: if self.rev() == introrev:
return self return self
return self.filectx(self.filenode(), changeid=introrev) return self.filectx(self.filenode(), changeid=introrev)
def _parentfilectx(self, path, fileid, filelog): def _parentfilectx(self, path, fileid, filelog):
"""create parent filectx keeping ancestry info for _adjustlinkrev()""" """create parent filectx keeping ancestry info for _adjustlinkrev()"""
fctx = filectx(self._repo, path, fileid=fileid, filelog=filelog) fctx = filectx(self._repo, path, fileid=fileid, filelog=filelog)
if r'_changeid' in vars(self) or r'_changectx' in vars(self): if '_changeid' in vars(self) or '_changectx' in vars(self):
# If self is associated with a changeset (probably explicitly # If self is associated with a changeset (probably explicitly
# fed), ensure the created filectx is associated with a # fed), ensure the created filectx is associated with a
# changeset that is an ancestor of self.changectx. # changeset that is an ancestor of self.changectx.
# This lets us later use _adjustlinkrev to get a correct link. # This lets us later use _adjustlinkrev to get a correct link.
fctx._descendantrev = self.rev() fctx._descendantrev = self.rev()
fctx._ancestrycontext = getattr(self, '_ancestrycontext', None) fctx._ancestrycontext = getattr(self, '_ancestrycontext', None)
elif r'_descendantrev' in vars(self): elif '_descendantrev' in vars(self):
# Otherwise propagate _descendantrev if we have one associated. # Otherwise propagate _descendantrev if we have one associated.
fctx._descendantrev = self._descendantrev fctx._descendantrev = self._descendantrev
fctx._ancestrycontext = getattr(self, '_ancestrycontext', None) fctx._ancestrycontext = getattr(self, '_ancestrycontext', None)
return fctx return fctx
def parents(self): def parents(self):
_path = self._path _path = self._path
fl = self._filelog fl = self._filelog
# Don't return renamed parents if we aren't following. # Don't return renamed parents if we aren't following.
if not follow: if not follow:
pl = [p for p in pl if p.path() == f.path()] pl = [p for p in pl if p.path() == f.path()]
# renamed filectx won't have a filelog yet, so set it # renamed filectx won't have a filelog yet, so set it
# from the cache to save time # from the cache to save time
for p in pl: for p in pl:
if not r'_filelog' in p.__dict__: if not '_filelog' in p.__dict__:
p._filelog = getlog(p.path()) p._filelog = getlog(p.path())
return pl return pl
# use linkrev to find the first changeset where self appeared # use linkrev to find the first changeset where self appeared
base = self.introfilectx() base = self.introfilectx()
if getattr(base, '_ancestrycontext', None) is None: if getattr(base, '_ancestrycontext', None) is None:
cl = self._repo.changelog cl = self._repo.changelog
return func return func
@propertycache @propertycache
def _flagfunc(self): def _flagfunc(self):
return self._repo.dirstate.flagfunc(self._buildflagfunc) return self._repo.dirstate.flagfunc(self._buildflagfunc)
def flags(self, path): def flags(self, path):
if r'_manifest' in self.__dict__: if '_manifest' in self.__dict__:
try: try:
return self._manifest.flags(path) return self._manifest.flags(path)
except KeyError: except KeyError:
return b'' return b''
try: try:
return self._flagfunc(path) return self._flagfunc(path)
except OSError: except OSError:

mercurial/crecord.py

return patchmod.recordhunk( return patchmod.recordhunk(
h.header, h.toline, h.fromline, h.proc, h.before, hunk, h.after h.header, h.toline, h.fromline, h.proc, h.before, hunk, h.after
) )
def __getattr__(self, name): def __getattr__(self, name):
return getattr(self._hunk, name) return getattr(self._hunk, name)
def __repr__(self): def __repr__(self):
return r'<hunk %r@%d>' % (self.filename(), self.fromline) return '<hunk %r@%d>' % (self.filename(), self.fromline)
def filterpatch(ui, chunks, chunkselector, operation=None): def filterpatch(ui, chunks, chunkselector, operation=None):
"""interactively filter patch chunks into applied-only chunks""" """interactively filter patch chunks into applied-only chunks"""
chunks = list(chunks) chunks = list(chunks)
# convert chunks list into structure suitable for displaying/modifying # convert chunks list into structure suitable for displaying/modifying
# with curses. create a list of headers only. # with curses. create a list of headers only.
headers = [c for c in chunks if isinstance(c, patchmod.header)] headers = [c for c in chunks if isinstance(c, patchmod.header)]
""" """
curses interface to get selection of chunks, and mark the applied flags curses interface to get selection of chunks, and mark the applied flags
of the chosen chunks. of the chosen chunks.
""" """
ui.write(_(b'starting interactive selection\n')) ui.write(_(b'starting interactive selection\n'))
chunkselector = curseschunkselector(headerlist, ui, operation) chunkselector = curseschunkselector(headerlist, ui, operation)
# This is required for ncurses to display non-ASCII characters in # This is required for ncurses to display non-ASCII characters in
# default user locale encoding correctly. --immerrr # default user locale encoding correctly. --immerrr
locale.setlocale(locale.LC_ALL, r'') locale.setlocale(locale.LC_ALL, '')
origsigtstp = sentinel = object() origsigtstp = sentinel = object()
if util.safehasattr(signal, b'SIGTSTP'): if util.safehasattr(signal, b'SIGTSTP'):
origsigtstp = signal.getsignal(signal.SIGTSTP) origsigtstp = signal.getsignal(signal.SIGTSTP)
try: try:
curses.wrapper(chunkselector.main) curses.wrapper(chunkselector.main)
if chunkselector.initexc is not None: if chunkselector.initexc is not None:
raise chunkselector.initexc raise chunkselector.initexc
# ncurses does not restore signal handler for SIGTSTP # ncurses does not restore signal handler for SIGTSTP

mercurial/debugcommands.py

return pycompat.bytestr(repr(thing)) return pycompat.bytestr(repr(thing))
def _debugbundle2(ui, gen, all=None, **opts): def _debugbundle2(ui, gen, all=None, **opts):
"""lists the contents of a bundle2""" """lists the contents of a bundle2"""
if not isinstance(gen, bundle2.unbundle20): if not isinstance(gen, bundle2.unbundle20):
raise error.Abort(_(b'not a bundle2 file')) raise error.Abort(_(b'not a bundle2 file'))
ui.write((b'Stream params: %s\n' % _quasirepr(gen.params))) ui.write((b'Stream params: %s\n' % _quasirepr(gen.params)))
parttypes = opts.get(r'part_type', []) parttypes = opts.get('part_type', [])
for part in gen.iterparts(): for part in gen.iterparts():
if parttypes and part.type not in parttypes: if parttypes and part.type not in parttypes:
continue continue
msg = b'%s -- %s (mandatory: %r)\n' msg = b'%s -- %s (mandatory: %r)\n'
ui.write((msg % (part.type, _quasirepr(part.params), part.mandatory))) ui.write((msg % (part.type, _quasirepr(part.params), part.mandatory)))
if part.type == b'changegroup': if part.type == b'changegroup':
version = part.params.get(b'version', b'01') version = part.params.get(b'version', b'01')
cg = changegroup.getunbundler(version, part, b'UN') cg = changegroup.getunbundler(version, part, b'UN')
@command( @command(
b'debugcolor', b'debugcolor',
[(b'', b'style', None, _(b'show all configured styles'))], [(b'', b'style', None, _(b'show all configured styles'))],
b'hg debugcolor', b'hg debugcolor',
) )
def debugcolor(ui, repo, **opts): def debugcolor(ui, repo, **opts):
"""show available color, effects or style""" """show available color, effects or style"""
ui.writenoi18n(b'color mode: %s\n' % stringutil.pprint(ui._colormode)) ui.writenoi18n(b'color mode: %s\n' % stringutil.pprint(ui._colormode))
if opts.get(r'style'): if opts.get('style'):
return _debugdisplaystyle(ui) return _debugdisplaystyle(ui)
else: else:
return _debugdisplaycolor(ui) return _debugdisplaycolor(ui)
def _debugdisplaycolor(ui): def _debugdisplaycolor(ui):
ui = ui.copy() ui = ui.copy()
ui._styles.clear() ui._styles.clear()
def debugdag(ui, repo, file_=None, *revs, **opts): def debugdag(ui, repo, file_=None, *revs, **opts):
"""format the changelog or an index DAG as a concise textual description """format the changelog or an index DAG as a concise textual description
If you pass a revlog index, the revlog's DAG is emitted. If you list If you pass a revlog index, the revlog's DAG is emitted. If you list
revision numbers, they get labeled in the output as rN. revision numbers, they get labeled in the output as rN.
Otherwise, the changelog DAG of the current repo is emitted. Otherwise, the changelog DAG of the current repo is emitted.
""" """
spaces = opts.get(r'spaces') spaces = opts.get('spaces')
dots = opts.get(r'dots') dots = opts.get('dots')
if file_: if file_:
rlog = revlog.revlog(vfsmod.vfs(encoding.getcwd(), audit=False), file_) rlog = revlog.revlog(vfsmod.vfs(encoding.getcwd(), audit=False), file_)
revs = set((int(r) for r in revs)) revs = set((int(r) for r in revs))
def events(): def events():
for r in rlog: for r in rlog:
yield b'n', (r, list(p for p in rlog.parentrevs(r) if p != -1)) yield b'n', (r, list(p for p in rlog.parentrevs(r) if p != -1))
if r in revs: if r in revs:
yield b'l', (r, b"r%i" % r) yield b'l', (r, b"r%i" % r)
elif repo: elif repo:
cl = repo.changelog cl = repo.changelog
tags = opts.get(r'tags') tags = opts.get('tags')
branches = opts.get(r'branches') branches = opts.get('branches')
if tags: if tags:
labels = {} labels = {}
for l, n in repo.tags().items(): for l, n in repo.tags().items():
labels.setdefault(cl.rev(n), []).append(l) labels.setdefault(cl.rev(n), []).append(l)
def events(): def events():
b = b"default" b = b"default"
for r in cl: for r in cl:
(b'', b'dates', True, _(b'display the saved mtime')), (b'', b'dates', True, _(b'display the saved mtime')),
(b'', b'datesort', None, _(b'sort by saved mtime')), (b'', b'datesort', None, _(b'sort by saved mtime')),
], ],
_(b'[OPTION]...'), _(b'[OPTION]...'),
) )
def debugstate(ui, repo, **opts): def debugstate(ui, repo, **opts):
"""show the contents of the current dirstate""" """show the contents of the current dirstate"""
nodates = not opts[r'dates'] nodates = not opts['dates']
if opts.get(r'nodates') is not None: if opts.get('nodates') is not None:
nodates = True nodates = True
datesort = opts.get(r'datesort') datesort = opts.get('datesort')
if datesort: if datesort:
keyfunc = lambda x: (x[1][3], x[0]) # sort by mtime, then by filename keyfunc = lambda x: (x[1][3], x[0]) # sort by mtime, then by filename
else: else:
keyfunc = None # sort by filename keyfunc = None # sort by filename
for file_, ent in sorted(pycompat.iteritems(repo.dirstate), key=keyfunc): for file_, ent in sorted(pycompat.iteritems(repo.dirstate), key=keyfunc):
if ent[3] == -1: if ent[3] == -1:
timestr = b'unset ' timestr = b'unset '
given file. given file.
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
repo = hg.peer(ui, opts, repopath) repo = hg.peer(ui, opts, repopath)
if not repo.capable(b'getbundle'): if not repo.capable(b'getbundle'):
raise error.Abort(b"getbundle() not supported by target repository") raise error.Abort(b"getbundle() not supported by target repository")
args = {} args = {}
if common: if common:
args[r'common'] = [bin(s) for s in common] args['common'] = [bin(s) for s in common]
if head: if head:
args[r'heads'] = [bin(s) for s in head] args['heads'] = [bin(s) for s in head]
# TODO: get desired bundlecaps from command line. # TODO: get desired bundlecaps from command line.
args[r'bundlecaps'] = None args['bundlecaps'] = None
bundle = repo.getbundle(b'debug', **args) bundle = repo.getbundle(b'debug', **args)
bundletype = opts.get(b'type', b'bzip2').lower() bundletype = opts.get(b'type', b'bzip2').lower()
btypes = { btypes = {
b'none': b'HG10UN', b'none': b'HG10UN',
b'bzip2': b'HG10BZ', b'bzip2': b'HG10BZ',
b'gzip': b'HG10GZ', b'gzip': b'HG10GZ',
b'bundle2': b'HG20', b'bundle2': b'HG20',
Setting a lock will prevent other commands from changing the data. Setting a lock will prevent other commands from changing the data.
The command will wait until an interruption (SIGINT, SIGTERM, ...) occurs. The command will wait until an interruption (SIGINT, SIGTERM, ...) occurs.
The set locks are removed when the command exits. The set locks are removed when the command exits.
Returns 0 if no locks are held. Returns 0 if no locks are held.
""" """
if opts.get(r'force_lock'): if opts.get('force_lock'):
repo.svfs.unlink(b'lock') repo.svfs.unlink(b'lock')
if opts.get(r'force_wlock'): if opts.get('force_wlock'):
repo.vfs.unlink(b'wlock') repo.vfs.unlink(b'wlock')
if opts.get(r'force_lock') or opts.get(r'force_wlock'): if opts.get('force_lock') or opts.get('force_wlock'):
return 0 return 0
locks = [] locks = []
try: try:
if opts.get(r'set_wlock'): if opts.get('set_wlock'):
try: try:
locks.append(repo.wlock(False)) locks.append(repo.wlock(False))
except error.LockHeld: except error.LockHeld:
raise error.Abort(_(b'wlock is already held')) raise error.Abort(_(b'wlock is already held'))
if opts.get(r'set_lock'): if opts.get('set_lock'):
try: try:
locks.append(repo.lock(False)) locks.append(repo.lock(False))
except error.LockHeld: except error.LockHeld:
raise error.Abort(_(b'lock is already held')) raise error.Abort(_(b'lock is already held'))
if len(locks): if len(locks):
ui.promptchoice(_(b"ready to release the lock (y)? $$ &Yes")) ui.promptchoice(_(b"ready to release the lock (y)? $$ &Yes"))
return 0 return 0
finally: finally:
return r._fulltextcache return r._fulltextcache
except AttributeError: except AttributeError:
msg = _( msg = _(
b"Current revlog implementation doesn't appear to have a " b"Current revlog implementation doesn't appear to have a "
b"manifest fulltext cache\n" b"manifest fulltext cache\n"
) )
raise error.Abort(msg) raise error.Abort(msg)
if opts.get(r'clear'): if opts.get('clear'):
with repo.wlock(): with repo.wlock():
cache = getcache() cache = getcache()
cache.clear(clear_persisted_data=True) cache.clear(clear_persisted_data=True)
return return
if add: if add:
with repo.wlock(): with repo.wlock():
m = repo.manifestlog m = repo.manifestlog
return [], [] return [], []
if os.path.isdir(spec): if os.path.isdir(spec):
spec += b'/' spec += b'/'
spec = spec[len(rootdir) :] spec = spec[len(rootdir) :]
fixpaths = pycompat.ossep != b'/' fixpaths = pycompat.ossep != b'/'
if fixpaths: if fixpaths:
spec = spec.replace(pycompat.ossep, b'/') spec = spec.replace(pycompat.ossep, b'/')
speclen = len(spec) speclen = len(spec)
fullpaths = opts[r'full'] fullpaths = opts['full']
files, dirs = set(), set() files, dirs = set(), set()
adddir, addfile = dirs.add, files.add adddir, addfile = dirs.add, files.add
for f, st in pycompat.iteritems(dirstate): for f, st in pycompat.iteritems(dirstate):
if f.startswith(spec) and st[0] in acceptable: if f.startswith(spec) and st[0] in acceptable:
if fixpaths: if fixpaths:
f = f.replace(b'/', pycompat.ossep) f = f.replace(b'/', pycompat.ossep)
if fullpaths: if fullpaths:
addfile(f) addfile(f)
continue continue
s = f.find(pycompat.ossep, speclen) s = f.find(pycompat.ossep, speclen)
if s >= 0: if s >= 0:
adddir(f[:s]) adddir(f[:s])
else: else:
addfile(f) addfile(f)
return files, dirs return files, dirs
acceptable = b'' acceptable = b''
if opts[r'normal']: if opts['normal']:
acceptable += b'nm' acceptable += b'nm'
if opts[r'added']: if opts['added']:
acceptable += b'a' acceptable += b'a'
if opts[r'removed']: if opts['removed']:
acceptable += b'r' acceptable += b'r'
cwd = repo.getcwd() cwd = repo.getcwd()
if not specs: if not specs:
specs = [b'.'] specs = [b'.']
files, dirs = set(), set() files, dirs = set(), set()
for spec in specs: for spec in specs:
f, d = complete(spec, acceptable or b'nmar') f, d = complete(spec, acceptable or b'nmar')
One use of this command is to make the next :hg:`status` invocation One use of this command is to make the next :hg:`status` invocation
check the actual file content. check the actual file content.
""" """
ctx = scmutil.revsingle(repo, rev) ctx = scmutil.revsingle(repo, rev)
with repo.wlock(): with repo.wlock():
dirstate = repo.dirstate dirstate = repo.dirstate
changedfiles = None changedfiles = None
# See command doc for what minimal does. # See command doc for what minimal does.
if opts.get(r'minimal'): if opts.get('minimal'):
manifestfiles = set(ctx.manifest().keys()) manifestfiles = set(ctx.manifest().keys())
dirstatefiles = set(dirstate) dirstatefiles = set(dirstate)
manifestonly = manifestfiles - dirstatefiles manifestonly = manifestfiles - dirstatefiles
dsonly = dirstatefiles - manifestfiles dsonly = dirstatefiles - manifestfiles
dsnotadded = set(f for f in dsonly if dirstate[f] != b'a') dsnotadded = set(f for f in dsonly if dirstate[f] != b'a')
changedfiles = manifestonly | dsnotadded changedfiles = manifestonly | dsnotadded
dirstate.rebuild(ctx.node(), ctx.manifest(), changedfiles) dirstate.rebuild(ctx.node(), ctx.manifest(), changedfiles)
arevs = list(arevs) arevs = list(arevs)
brevs = list(brevs) brevs = list(brevs)
if arevs == brevs: if arevs == brevs:
return 0 return 0
ui.writenoi18n(b'--- analyzed\n', label=b'diff.file_a') ui.writenoi18n(b'--- analyzed\n', label=b'diff.file_a')
ui.writenoi18n(b'+++ optimized\n', label=b'diff.file_b') ui.writenoi18n(b'+++ optimized\n', label=b'diff.file_b')
sm = difflib.SequenceMatcher(None, arevs, brevs) sm = difflib.SequenceMatcher(None, arevs, brevs)
for tag, alo, ahi, blo, bhi in sm.get_opcodes(): for tag, alo, ahi, blo, bhi in sm.get_opcodes():
if tag in (r'delete', r'replace'): if tag in ('delete', 'replace'):
for c in arevs[alo:ahi]: for c in arevs[alo:ahi]:
ui.write(b'-%d\n' % c, label=b'diff.deleted') ui.write(b'-%d\n' % c, label=b'diff.deleted')
if tag in (r'insert', r'replace'): if tag in ('insert', 'replace'):
for c in brevs[blo:bhi]: for c in brevs[blo:bhi]:
ui.write(b'+%d\n' % c, label=b'diff.inserted') ui.write(b'+%d\n' % c, label=b'diff.inserted')
if tag == r'equal': if tag == 'equal':
for c in arevs[alo:ahi]: for c in arevs[alo:ahi]:
ui.write(b' %d\n' % c) ui.write(b' %d\n' % c)
return 1 return 1
func = revset.makematcher(tree) func = revset.makematcher(tree)
revs = func(repo) revs = func(repo)
if opts[b'show_set'] or (opts[b'show_set'] is None and ui.verbose): if opts[b'show_set'] or (opts[b'show_set'] is None and ui.verbose):
ui.writenoi18n(b"* set:\n", stringutil.prettyrepr(revs), b"\n") ui.writenoi18n(b"* set:\n", stringutil.prettyrepr(revs), b"\n")
logfh = None logfh = None
if opts[b'logiofd'] and opts[b'logiofile']: if opts[b'logiofd'] and opts[b'logiofile']:
raise error.Abort(_(b'cannot use both --logiofd and --logiofile')) raise error.Abort(_(b'cannot use both --logiofd and --logiofile'))
if opts[b'logiofd']: if opts[b'logiofd']:
# Line buffered because output is line based. # Line buffered because output is line based.
try: try:
logfh = os.fdopen(int(opts[b'logiofd']), r'ab', 1) logfh = os.fdopen(int(opts[b'logiofd']), 'ab', 1)
except OSError as e: except OSError as e:
if e.errno != errno.ESPIPE: if e.errno != errno.ESPIPE:
raise raise
# can't seek a pipe, so `ab` mode fails on py3 # can't seek a pipe, so `ab` mode fails on py3
logfh = os.fdopen(int(opts[b'logiofd']), r'wb', 1) logfh = os.fdopen(int(opts[b'logiofd']), 'wb', 1)
elif opts[b'logiofile']: elif opts[b'logiofile']:
logfh = open(opts[b'logiofile'], b'ab', 1) logfh = open(opts[b'logiofile'], b'ab', 1)
s = wireprotoserver.sshserver(ui, repo, logfh=logfh) s = wireprotoserver.sshserver(ui, repo, logfh=logfh)
s.serve_forever() s.serve_forever()
@command(b'debugsetparents', [], _(b'REV1 [REV2]')) @command(b'debugsetparents', [], _(b'REV1 [REV2]'))
# passed to successorssets caching computation from one call to another # passed to successorssets caching computation from one call to another
cache = {} cache = {}
ctx2str = bytes ctx2str = bytes
node2str = short node2str = short
for rev in scmutil.revrange(repo, revs): for rev in scmutil.revrange(repo, revs):
ctx = repo[rev] ctx = repo[rev]
ui.write(b'%s\n' % ctx2str(ctx)) ui.write(b'%s\n' % ctx2str(ctx))
for succsset in obsutil.successorssets( for succsset in obsutil.successorssets(
repo, ctx.node(), closest=opts[r'closest'], cache=cache repo, ctx.node(), closest=opts['closest'], cache=cache
): ):
if succsset: if succsset:
ui.write(b' ') ui.write(b' ')
ui.write(node2str(succsset[0])) ui.write(node2str(succsset[0]))
for node in succsset[1:]: for node in succsset[1:]:
ui.write(b' ') ui.write(b' ')
ui.write(node2str(node)) ui.write(node2str(node))
ui.write(b'\n') ui.write(b'\n')
If -r/--rev is given, the template is processed as a log template and If -r/--rev is given, the template is processed as a log template and
applied to the given changesets. Otherwise, it is processed as a generic applied to the given changesets. Otherwise, it is processed as a generic
template. template.
Use --verbose to print the parsed tree. Use --verbose to print the parsed tree.
""" """
revs = None revs = None
if opts[r'rev']: if opts['rev']:
if repo is None: if repo is None:
raise error.RepoError( raise error.RepoError(
_(b'there is no Mercurial repository here (.hg not found)') _(b'there is no Mercurial repository here (.hg not found)')
) )
revs = scmutil.revrange(repo, opts[r'rev']) revs = scmutil.revrange(repo, opts['rev'])
props = {} props = {}
for d in opts[r'define']: for d in opts['define']:
try: try:
k, v = (e.strip() for e in d.split(b'=', 1)) k, v = (e.strip() for e in d.split(b'=', 1))
if not k or k == b'ui': if not k or k == b'ui':
raise ValueError raise ValueError
props[k] = v props[k] = v
except ValueError: except ValueError:
raise error.Abort(_(b'malformed keyword definition: %s') % d) raise error.Abort(_(b'malformed keyword definition: %s') % d)
# TODO consider not doing this because we skip # TODO consider not doing this because we skip
# ``hg.wirepeersetupfuncs`` and potentially other useful functionality. # ``hg.wirepeersetupfuncs`` and potentially other useful functionality.
u = util.url(path) u = util.url(path)
if u.scheme != b'http': if u.scheme != b'http':
raise error.Abort(_(b'only http:// paths are currently supported')) raise error.Abort(_(b'only http:// paths are currently supported'))
url, authinfo = u.authinfo() url, authinfo = u.authinfo()
openerargs = { openerargs = {
r'useragent': b'Mercurial debugwireproto', 'useragent': b'Mercurial debugwireproto',
} }
# Turn pipes/sockets into observers so we can log I/O. # Turn pipes/sockets into observers so we can log I/O.
if ui.verbose: if ui.verbose:
openerargs.update( openerargs.update(
{ {
r'loggingfh': ui, 'loggingfh': ui,
r'loggingname': b's', 'loggingname': b's',
r'loggingopts': {r'logdata': True, r'logdataapis': False,}, 'loggingopts': {'logdata': True, 'logdataapis': False,},
} }
) )
if ui.debugflag: if ui.debugflag:
openerargs[r'loggingopts'][r'logdataapis'] = True openerargs['loggingopts']['logdataapis'] = True
# Don't send default headers when in raw mode. This allows us to # Don't send default headers when in raw mode. This allows us to
# bypass most of the behavior of our URL handling code so we can # bypass most of the behavior of our URL handling code so we can
# have near complete control over what's sent on the wire. # have near complete control over what's sent on the wire.
if opts[b'peer'] == b'raw': if opts[b'peer'] == b'raw':
openerargs[r'sendaccept'] = False openerargs['sendaccept'] = False
opener = urlmod.opener(ui, authinfo, **openerargs) opener = urlmod.opener(ui, authinfo, **openerargs)
if opts[b'peer'] == b'http2': if opts[b'peer'] == b'http2':
ui.write(_(b'creating http peer for wire protocol version 2\n')) ui.write(_(b'creating http peer for wire protocol version 2\n'))
# We go through makepeer() because we need an API descriptor for # We go through makepeer() because we need an API descriptor for
# the peer instance to be useful. # the peer instance to be useful.
with ui.configoverride( with ui.configoverride(
if batchedcommands is not None: if batchedcommands is not None:
batchedcommands.append((command, args)) batchedcommands.append((command, args))
continue continue
ui.status(_(b'sending %s command\n') % command) ui.status(_(b'sending %s command\n') % command)
if b'PUSHFILE' in args: if b'PUSHFILE' in args:
with open(args[b'PUSHFILE'], r'rb') as fh: with open(args[b'PUSHFILE'], 'rb') as fh:
del args[b'PUSHFILE'] del args[b'PUSHFILE']
res, output = peer._callpush( res, output = peer._callpush(
command, fh, **pycompat.strkwargs(args) command, fh, **pycompat.strkwargs(args)
) )
ui.status(_(b'result: %s\n') % stringutil.escapestr(res)) ui.status(_(b'result: %s\n') % stringutil.escapestr(res))
ui.status( ui.status(
_(b'remote output: %s\n') % stringutil.escapestr(output) _(b'remote output: %s\n') % stringutil.escapestr(output)
) )
try: try:
res = opener.open(req) res = opener.open(req)
body = res.read() body = res.read()
except util.urlerr.urlerror as e: except util.urlerr.urlerror as e:
# read() method must be called, but only exists in Python 2 # read() method must be called, but only exists in Python 2
getattr(e, 'read', lambda: None)() getattr(e, 'read', lambda: None)()
continue continue
ct = res.headers.get(r'Content-Type') ct = res.headers.get('Content-Type')
if ct == r'application/mercurial-cbor': if ct == 'application/mercurial-cbor':
ui.write( ui.write(
_(b'cbor> %s\n') _(b'cbor> %s\n')
% stringutil.pprint( % stringutil.pprint(
cborutil.decodeall(body), bprefix=True, indent=2 cborutil.decodeall(body), bprefix=True, indent=2
) )
) )
elif action == b'close': elif action == b'close':

mercurial/dirstate.py

util, util,
) )
from .interfaces import ( from .interfaces import (
dirstate as intdirstate, dirstate as intdirstate,
util as interfaceutil, util as interfaceutil,
) )
parsers = policy.importmod(r'parsers') parsers = policy.importmod('parsers')
rustmod = policy.importrust(r'dirstate') rustmod = policy.importrust('dirstate')
propertycache = util.propertycache propertycache = util.propertycache
filecache = scmutil.filecache filecache = scmutil.filecache
_rangemask = 0x7FFFFFFF _rangemask = 0x7FFFFFFF
dirstatetuple = parsers.dirstatetuple dirstatetuple = parsers.dirstatetuple

mercurial/dispatch.py

@property @property
def args(self): def args(self):
args = pycompat.maplist(util.expandpath, self.givenargs) args = pycompat.maplist(util.expandpath, self.givenargs)
return aliasargs(self.fn, args) return aliasargs(self.fn, args)
def __getattr__(self, name): def __getattr__(self, name):
adefaults = { adefaults = {
r'norepo': True, 'norepo': True,
r'intents': set(), 'intents': set(),
r'optionalrepo': False, 'optionalrepo': False,
r'inferrepo': False, 'inferrepo': False,
} }
if name not in adefaults: if name not in adefaults:
raise AttributeError(name) raise AttributeError(name)
if self.badalias or util.safehasattr(self, b'shell'): if self.badalias or util.safehasattr(self, b'shell'):
return adefaults[name] return adefaults[name]
return getattr(self.fn, name) return getattr(self.fn, name)
def __call__(self, ui, *args, **opts): def __call__(self, ui, *args, **opts):

mercurial/encoding.py

from . import ( from . import (
error, error,
policy, policy,
pycompat, pycompat,
) )
from .pure import charencode as charencodepure from .pure import charencode as charencodepure
charencode = policy.importmod(r'charencode') charencode = policy.importmod('charencode')
isasciistr = charencode.isasciistr isasciistr = charencode.isasciistr
asciilower = charencode.asciilower asciilower = charencode.asciilower
asciiupper = charencode.asciiupper asciiupper = charencode.asciiupper
_jsonescapeu8fast = charencode.jsonescapeu8fast _jsonescapeu8fast = charencode.jsonescapeu8fast
_sysstr = pycompat.sysstr _sysstr = pycompat.sysstr
if not pycompat.ispy3: if not pycompat.ispy3:
environ = os.environ # re-exports environ = os.environ # re-exports
elif _nativeenviron: elif _nativeenviron:
environ = os.environb # re-exports environ = os.environb # re-exports
else: else:
# preferred encoding isn't known yet; use utf-8 to avoid unicode error # preferred encoding isn't known yet; use utf-8 to avoid unicode error
# and recreate it once encoding is settled # and recreate it once encoding is settled
environ = dict( environ = dict(
(k.encode(r'utf-8'), v.encode(r'utf-8')) (k.encode('utf-8'), v.encode('utf-8'))
for k, v in os.environ.items() # re-exports for k, v in os.environ.items() # re-exports
) )
_encodingrewrites = { _encodingrewrites = {
b'646': b'ascii', b'646': b'ascii',
b'ANSI_X3.4-1968': b'ascii', b'ANSI_X3.4-1968': b'ascii',
} }
# cp65001 is a Windows variant of utf-8, which isn't supported on Python 2. # cp65001 is a Windows variant of utf-8, which isn't supported on Python 2.
strtolocal = pycompat.identity strtolocal = pycompat.identity
strfromlocal = pycompat.identity strfromlocal = pycompat.identity
strmethod = pycompat.identity strmethod = pycompat.identity
if not _nativeenviron: if not _nativeenviron:
# now encoding and helper functions are available, recreate the environ # now encoding and helper functions are available, recreate the environ
# dict to be exported to other modules # dict to be exported to other modules
environ = dict( environ = dict(
(tolocal(k.encode(r'utf-8')), tolocal(v.encode(r'utf-8'))) (tolocal(k.encode('utf-8')), tolocal(v.encode('utf-8')))
for k, v in os.environ.items() # re-exports for k, v in os.environ.items() # re-exports
) )
if pycompat.ispy3: if pycompat.ispy3:
# os.getcwd() on Python 3 returns string, but it has os.getcwdb() which # os.getcwd() on Python 3 returns string, but it has os.getcwdb() which
# returns bytes. # returns bytes.
if pycompat.iswindows: if pycompat.iswindows:
# Python 3 on Windows issues a DeprecationWarning about using the bytes # Python 3 on Windows issues a DeprecationWarning about using the bytes
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):
b"Find the column width of a string for display in the local encoding" b"Find the column width of a string for display in the local encoding"
return ucolwidth(s.decode(_sysstr(encoding), r'replace')) return ucolwidth(s.decode(_sysstr(encoding), 'replace'))
def ucolwidth(d): def ucolwidth(d):
b"Find the column width of a Unicode string for display" b"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)

mercurial/error.py

class Hint(object): class Hint(object):
"""Mix-in to provide a hint of an error """Mix-in to provide a hint of an error
This should come first in the inheritance list to consume a hint and This should come first in the inheritance list to consume a hint and
pass remaining arguments to the exception class. pass remaining arguments to the exception class.
""" """
def __init__(self, *args, **kw): def __init__(self, *args, **kw):
self.hint = kw.pop(r'hint', None) self.hint = kw.pop('hint', None)
super(Hint, self).__init__(*args, **kw) super(Hint, self).__init__(*args, **kw)
class StorageError(Hint, Exception): class StorageError(Hint, Exception):
"""Raised when an error occurs in a storage layer. """Raised when an error occurs in a storage layer.
Usually subclassed by a storage-specific exception. Usually subclassed by a storage-specific exception.
""" """

mercurial/exchange.py

user_includes = [ user_includes = [
b'path:.' if p == b'*' else b'path:' + p for p in user_includes b'path:.' if p == b'*' else b'path:' + p for p in user_includes
] ]
user_excludes = [ user_excludes = [
b'path:.' if p == b'*' else b'path:' + p for p in user_excludes b'path:.' if p == b'*' else b'path:' + p for p in user_excludes
] ]
req_includes = set(kwargs.get(r'includepats', [])) req_includes = set(kwargs.get('includepats', []))
req_excludes = set(kwargs.get(r'excludepats', [])) req_excludes = set(kwargs.get('excludepats', []))
req_includes, req_excludes, invalid_includes = narrowspec.restrictpatterns( req_includes, req_excludes, invalid_includes = narrowspec.restrictpatterns(
req_includes, req_excludes, user_includes, user_excludes req_includes, req_excludes, user_includes, user_excludes
) )
if invalid_includes: if invalid_includes:
raise error.Abort( raise error.Abort(
_(b"The following includes are not accessible for {}: {}").format( _(b"The following includes are not accessible for {}: {}").format(
username, invalid_includes username, invalid_includes
) )
) )
new_args = {} new_args = {}
new_args.update(kwargs) new_args.update(kwargs)
new_args[r'narrow'] = True new_args['narrow'] = True
new_args[r'narrow_acl'] = True new_args['narrow_acl'] = True
new_args[r'includepats'] = req_includes new_args['includepats'] = req_includes
if req_excludes: if req_excludes:
new_args[r'excludepats'] = req_excludes new_args['excludepats'] = req_excludes
return new_args return new_args
def _computeellipsis(repo, common, heads, known, match, depth=None): def _computeellipsis(repo, common, heads, known, match, depth=None):
"""Compute the shape of a narrowed DAG. """Compute the shape of a narrowed DAG.
Args: Args:
source, source,
bundlecaps=None, bundlecaps=None,
b2caps=None, b2caps=None,
heads=None, heads=None,
common=None, common=None,
**kwargs **kwargs
): ):
"""add a changegroup part to the requested bundle""" """add a changegroup part to the requested bundle"""
if not kwargs.get(r'cg', True): if not kwargs.get('cg', True):
return return
version = b'01' version = b'01'
cgversions = b2caps.get(b'changegroup') cgversions = b2caps.get(b'changegroup')
if cgversions: # 3.1 and 3.2 ship with an empty value if cgversions: # 3.1 and 3.2 ship with an empty value
cgversions = [ cgversions = [
v v
for v in cgversions for v in cgversions
if v in changegroup.supportedoutgoingversions(repo) if v in changegroup.supportedoutgoingversions(repo)
] ]
if not cgversions: if not cgversions:
raise error.Abort(_(b'no common changegroup version')) raise error.Abort(_(b'no common changegroup version'))
version = max(cgversions) version = max(cgversions)
outgoing = _computeoutgoing(repo, heads, common) outgoing = _computeoutgoing(repo, heads, common)
if not outgoing.missing: if not outgoing.missing:
return return
if kwargs.get(r'narrow', False): if kwargs.get('narrow', False):
include = sorted(filter(bool, kwargs.get(r'includepats', []))) include = sorted(filter(bool, kwargs.get('includepats', [])))
exclude = sorted(filter(bool, kwargs.get(r'excludepats', []))) exclude = sorted(filter(bool, kwargs.get('excludepats', [])))
matcher = narrowspec.match(repo.root, include=include, exclude=exclude) matcher = narrowspec.match(repo.root, include=include, exclude=exclude)
else: else:
matcher = None matcher = None
cgstream = changegroup.makestream( cgstream = changegroup.makestream(
repo, outgoing, version, source, bundlecaps=bundlecaps, matcher=matcher repo, outgoing, version, source, bundlecaps=bundlecaps, matcher=matcher
) )
part = bundler.newpart(b'changegroup', data=cgstream) part = bundler.newpart(b'changegroup', data=cgstream)
if cgversions: if cgversions:
part.addparam(b'version', version) part.addparam(b'version', version)
part.addparam(b'nbchanges', b'%d' % len(outgoing.missing), mandatory=False) part.addparam(b'nbchanges', b'%d' % len(outgoing.missing), mandatory=False)
if b'treemanifest' in repo.requirements: if b'treemanifest' in repo.requirements:
part.addparam(b'treemanifest', b'1') part.addparam(b'treemanifest', b'1')
if b'exp-sidedata-flag' in repo.requirements: if b'exp-sidedata-flag' in repo.requirements:
part.addparam(b'exp-sidedata', b'1') part.addparam(b'exp-sidedata', b'1')
if ( if (
kwargs.get(r'narrow', False) kwargs.get('narrow', False)
and kwargs.get(r'narrow_acl', False) and kwargs.get('narrow_acl', False)
and (include or exclude) and (include or exclude)
): ):
# this is mandatory because otherwise ACL clients won't work # this is mandatory because otherwise ACL clients won't work
narrowspecpart = bundler.newpart(b'Narrow:responsespec') narrowspecpart = bundler.newpart(b'Narrow:responsespec')
narrowspecpart.data = b'%s\0%s' % ( narrowspecpart.data = b'%s\0%s' % (
b'\n'.join(include), b'\n'.join(include),
b'\n'.join(exclude), b'\n'.join(exclude),
) )
@getbundle2partsgenerator(b'bookmarks') @getbundle2partsgenerator(b'bookmarks')
def _getbundlebookmarkpart( def _getbundlebookmarkpart(
bundler, repo, source, bundlecaps=None, b2caps=None, **kwargs bundler, repo, source, bundlecaps=None, b2caps=None, **kwargs
): ):
"""add a bookmark part to the requested bundle""" """add a bookmark part to the requested bundle"""
if not kwargs.get(r'bookmarks', False): if not kwargs.get('bookmarks', False):
return return
if b'bookmarks' not in b2caps: if b'bookmarks' not in b2caps:
raise error.Abort(_(b'no common bookmarks exchange method')) raise error.Abort(_(b'no common bookmarks exchange method'))
books = bookmod.listbinbookmarks(repo) books = bookmod.listbinbookmarks(repo)
data = bookmod.binaryencode(books) data = bookmod.binaryencode(books)
if data: if data:
bundler.newpart(b'bookmarks', data=data) bundler.newpart(b'bookmarks', data=data)
@getbundle2partsgenerator(b'listkeys') @getbundle2partsgenerator(b'listkeys')
def _getbundlelistkeysparts( def _getbundlelistkeysparts(
bundler, repo, source, bundlecaps=None, b2caps=None, **kwargs bundler, repo, source, bundlecaps=None, b2caps=None, **kwargs
): ):
"""add parts containing listkeys namespaces to the requested bundle""" """add parts containing listkeys namespaces to the requested bundle"""
listkeys = kwargs.get(r'listkeys', ()) listkeys = kwargs.get('listkeys', ())
for namespace in listkeys: for namespace in listkeys:
part = bundler.newpart(b'listkeys') part = bundler.newpart(b'listkeys')
part.addparam(b'namespace', namespace) part.addparam(b'namespace', namespace)
keys = repo.listkeys(namespace).items() keys = repo.listkeys(namespace).items()
part.data = pushkey.encodekeys(keys) part.data = pushkey.encodekeys(keys)
@getbundle2partsgenerator(b'obsmarkers') @getbundle2partsgenerator(b'obsmarkers')
def _getbundleobsmarkerpart( def _getbundleobsmarkerpart(
bundler, repo, source, bundlecaps=None, b2caps=None, heads=None, **kwargs bundler, repo, source, bundlecaps=None, b2caps=None, heads=None, **kwargs
): ):
"""add an obsolescence markers part to the requested bundle""" """add an obsolescence markers part to the requested bundle"""
if kwargs.get(r'obsmarkers', False): if kwargs.get('obsmarkers', False):
if heads is None: if heads is None:
heads = repo.heads() heads = repo.heads()
subset = [c.node() for c in repo.set(b'::%ln', heads)] subset = [c.node() for c in repo.set(b'::%ln', heads)]
markers = repo.obsstore.relevantmarkers(subset) markers = repo.obsstore.relevantmarkers(subset)
markers = _sortedmarkers(markers) markers = _sortedmarkers(markers)
bundle2.buildobsmarkerspart(bundler, markers) bundle2.buildobsmarkerspart(bundler, markers)
@getbundle2partsgenerator(b'phases') @getbundle2partsgenerator(b'phases')
def _getbundlephasespart( def _getbundlephasespart(
bundler, repo, source, bundlecaps=None, b2caps=None, heads=None, **kwargs bundler, repo, source, bundlecaps=None, b2caps=None, heads=None, **kwargs
): ):
"""add phase heads part to the requested bundle""" """add phase heads part to the requested bundle"""
if kwargs.get(r'phases', False): if kwargs.get('phases', False):
if not b'heads' in b2caps.get(b'phases'): if not b'heads' in b2caps.get(b'phases'):
raise error.Abort(_(b'no common phases exchange method')) raise error.Abort(_(b'no common phases exchange method'))
if heads is None: if heads is None:
heads = repo.heads() heads = repo.heads()
headsbyphase = collections.defaultdict(set) headsbyphase = collections.defaultdict(set)
if repo.publishing(): if repo.publishing():
headsbyphase[phases.public] = heads headsbyphase[phases.public] = heads
Only values for heads in this bundle will be transferred. Only values for heads in this bundle will be transferred.
The part data consists of pairs of 20 byte changeset node and .hgtags The part data consists of pairs of 20 byte changeset node and .hgtags
filenodes raw values. filenodes raw values.
""" """
# Don't send unless: # Don't send unless:
# - changeset are being exchanged, # - changeset are being exchanged,
# - the client supports it. # - the client supports it.
if not (kwargs.get(r'cg', True) and b'hgtagsfnodes' in b2caps): if not (kwargs.get('cg', True) and b'hgtagsfnodes' in b2caps):
return return
outgoing = _computeoutgoing(repo, heads, common) outgoing = _computeoutgoing(repo, heads, common)
bundle2.addparttagsfnodescache(repo, bundler, outgoing) bundle2.addparttagsfnodescache(repo, bundler, outgoing)
@getbundle2partsgenerator(b'cache:rev-branch-cache') @getbundle2partsgenerator(b'cache:rev-branch-cache')
def _getbundlerevbranchcache( def _getbundlerevbranchcache(
4) open heads nodes 4) open heads nodes
5) closed heads nodes 5) closed heads nodes
""" """
# Don't send unless: # Don't send unless:
# - changeset are being exchanged, # - changeset are being exchanged,
# - the client supports it. # - the client supports it.
# - narrow bundle isn't in play (not currently compatible). # - narrow bundle isn't in play (not currently compatible).
if ( if (
not kwargs.get(r'cg', True) not kwargs.get('cg', True)
or b'rev-branch-cache' not in b2caps or b'rev-branch-cache' not in b2caps
or kwargs.get(r'narrow', False) or kwargs.get('narrow', False)
or repo.ui.has_section(_NARROWACL_SECTION) or repo.ui.has_section(_NARROWACL_SECTION)
): ):
return return
outgoing = _computeoutgoing(repo, heads, common) outgoing = _computeoutgoing(repo, heads, common)
bundle2.addpartrevbranchcache(repo, bundler, outgoing) bundle2.addpartrevbranchcache(repo, bundler, outgoing)

mercurial/extensions.py

if not isinstance(node, ast.FunctionDef): if not isinstance(node, ast.FunctionDef):
todo.extend(ast.iter_child_nodes(node)) todo.extend(ast.iter_child_nodes(node))
continue continue
for d in node.decorator_list: for d in node.decorator_list:
if not isinstance(d, ast.Call): if not isinstance(d, ast.Call):
continue continue
if not isinstance(d.func, ast.Name): if not isinstance(d.func, ast.Name):
continue continue
if d.func.id != r'command': if d.func.id != 'command':
continue continue
yield d yield d
def _disabledcmdtable(path): def _disabledcmdtable(path):
"""Construct a dummy command table without loading the extension module """Construct a dummy command table without loading the extension module
This may raise IOError or SyntaxError. This may raise IOError or SyntaxError.

mercurial/help.py

if catfns: if catfns:
if len(cats) > 1: if len(cats) > 1:
catname = gettext(CATEGORY_NAMES[cat]) catname = gettext(CATEGORY_NAMES[cat])
rst.append(b"\n%s:\n" % catname) rst.append(b"\n%s:\n" % catname)
rst.append(b"\n") rst.append(b"\n")
appendcmds(catfns) appendcmds(catfns)
ex = opts.get ex = opts.get
anyopts = ex(r'keyword') or not (ex(r'command') or ex(r'extension')) anyopts = ex('keyword') or not (ex('command') or ex('extension'))
if not name and anyopts: if not name and anyopts:
exts = listexts( exts = listexts(
_(b'enabled extensions:'), _(b'enabled extensions:'),
extensions.enabled(), extensions.enabled(),
showdeprecated=ui.verbose, showdeprecated=ui.verbose,
) )
if exts: if exts:
rst.append(b'\n') rst.append(b'\n')

mercurial/hgweb/__init__.py

): ):
return return
if self.httpd.prefix: if self.httpd.prefix:
prefix = self.httpd.prefix.strip(b'/') + b'/' prefix = self.httpd.prefix.strip(b'/') + b'/'
else: else:
prefix = b'' prefix = b''
port = r':%d' % self.httpd.port port = ':%d' % self.httpd.port
if port == r':80': if port == ':80':
port = r'' port = ''
bindaddr = self.httpd.addr bindaddr = self.httpd.addr
if bindaddr == r'0.0.0.0': if bindaddr == '0.0.0.0':
bindaddr = r'*' bindaddr = '*'
elif r':' in bindaddr: # IPv6 elif ':' in bindaddr: # IPv6
bindaddr = r'[%s]' % bindaddr bindaddr = '[%s]' % bindaddr
fqaddr = self.httpd.fqaddr fqaddr = self.httpd.fqaddr
if r':' in fqaddr: if ':' in fqaddr:
fqaddr = r'[%s]' % fqaddr fqaddr = '[%s]' % fqaddr
url = b'http://%s%s/%s' % ( url = b'http://%s%s/%s' % (
pycompat.sysbytes(fqaddr), pycompat.sysbytes(fqaddr),
pycompat.sysbytes(port), pycompat.sysbytes(port),
prefix, prefix,
) )
if self.opts[b'print_url']: if self.opts[b'print_url']:
self.ui.write(b'%s\n' % url) self.ui.write(b'%s\n' % url)

mercurial/hgweb/common.py

def __getattr__(self, attr): def __getattr__(self, attr):
if attr in (b'close', b'readline', b'readlines', b'__iter__'): if attr in (b'close', b'readline', b'readlines', b'__iter__'):
return getattr(self.f, attr) return getattr(self.f, attr)
raise AttributeError raise AttributeError
def _statusmessage(code): def _statusmessage(code):
responses = httpserver.basehttprequesthandler.responses responses = httpserver.basehttprequesthandler.responses
return pycompat.bytesurl( return pycompat.bytesurl(responses.get(code, ('Error', 'Unknown error'))[0])
responses.get(code, (r'Error', r'Unknown error'))[0]
)
def statusmessage(code, message=None): def statusmessage(code, message=None):
return b'%d %s' % (code, message or _statusmessage(code)) return b'%d %s' % (code, message or _statusmessage(code))
def get_stat(spath, fn): def get_stat(spath, fn):
"""stat fn if it exists, spath otherwise""" """stat fn if it exists, spath otherwise"""

mercurial/hgweb/server.py

def _splitURI(uri): def _splitURI(uri):
"""Return path and query that has been split from uri """Return path and query that has been split from uri
Just like CGI environment, the path is unquoted, the query is Just like CGI environment, the path is unquoted, the query is
not. not.
""" """
if r'?' in uri: if '?' in uri:
path, query = uri.split(r'?', 1) path, query = uri.split('?', 1)
else: else:
path, query = uri, r'' path, query = uri, r''
return urlreq.unquote(path), query return urlreq.unquote(path), query
class _error_logger(object): class _error_logger(object):
def __init__(self, handler): def __init__(self, handler):
self.handler = handler self.handler = handler
fp.flush() fp.flush()
def log_error(self, format, *args): def log_error(self, format, *args):
self._log_any(self.server.errorlog, format, *args) self._log_any(self.server.errorlog, format, *args)
def log_message(self, format, *args): def log_message(self, format, *args):
self._log_any(self.server.accesslog, format, *args) self._log_any(self.server.accesslog, format, *args)
def log_request(self, code=r'-', size=r'-'): def log_request(self, code='-', size='-'):
xheaders = [] xheaders = []
if util.safehasattr(self, b'headers'): if util.safehasattr(self, b'headers'):
xheaders = [ xheaders = [
h for h in self.headers.items() if h[0].startswith(r'x-') h for h in self.headers.items() if h[0].startswith('x-')
] ]
self.log_message( self.log_message(
r'"%s" %s %s%s', '"%s" %s %s%s',
self.requestline, self.requestline,
str(code), str(code),
str(size), str(size),
r''.join([r' %s:%s' % h for h in sorted(xheaders)]), ''.join([' %s:%s' % h for h in sorted(xheaders)]),
) )
def do_write(self): def do_write(self):
try: try:
self.do_hgweb() self.do_hgweb()
except socket.error as inst: except socket.error as inst:
if inst.errno != errno.EPIPE: if inst.errno != errno.EPIPE:
raise raise
self.sent_headers = False self.sent_headers = False
path, query = _splitURI(self.path) path, query = _splitURI(self.path)
# Ensure the slicing of path below is valid # Ensure the slicing of path below is valid
if path != self.server.prefix and not path.startswith( if path != self.server.prefix and not path.startswith(
self.server.prefix + b'/' self.server.prefix + b'/'
): ):
self._start_response(pycompat.strurl(common.statusmessage(404)), []) self._start_response(pycompat.strurl(common.statusmessage(404)), [])
if self.command == r'POST': if self.command == 'POST':
# Paranoia: tell the client we're going to close the # Paranoia: tell the client we're going to close the
# socket so they don't try and reuse a socket that # socket so they don't try and reuse a socket that
# might have a POST body waiting to confuse us. We do # might have a POST body waiting to confuse us. We do
# this by directly munging self.saved_headers because # this by directly munging self.saved_headers because
# self._start_response ignores Connection headers. # self._start_response ignores Connection headers.
self.saved_headers = [(r'Connection', r'Close')] self.saved_headers = [('Connection', 'Close')]
self._write(b"Not Found") self._write(b"Not Found")
self._done() self._done()
return return
env = {} env = {}
env[r'GATEWAY_INTERFACE'] = r'CGI/1.1' env['GATEWAY_INTERFACE'] = 'CGI/1.1'
env[r'REQUEST_METHOD'] = self.command env['REQUEST_METHOD'] = self.command
env[r'SERVER_NAME'] = self.server.server_name env['SERVER_NAME'] = self.server.server_name
env[r'SERVER_PORT'] = str(self.server.server_port) env['SERVER_PORT'] = str(self.server.server_port)
env[r'REQUEST_URI'] = self.path env['REQUEST_URI'] = self.path
env[r'SCRIPT_NAME'] = pycompat.sysstr(self.server.prefix) env['SCRIPT_NAME'] = pycompat.sysstr(self.server.prefix)
env[r'PATH_INFO'] = pycompat.sysstr(path[len(self.server.prefix) :]) env['PATH_INFO'] = pycompat.sysstr(path[len(self.server.prefix) :])
env[r'REMOTE_HOST'] = self.client_address[0] env['REMOTE_HOST'] = self.client_address[0]
env[r'REMOTE_ADDR'] = self.client_address[0] env['REMOTE_ADDR'] = self.client_address[0]
env[r'QUERY_STRING'] = query or r'' env['QUERY_STRING'] = query or ''
if pycompat.ispy3: if pycompat.ispy3:
if self.headers.get_content_type() is None: if self.headers.get_content_type() is None:
env[r'CONTENT_TYPE'] = self.headers.get_default_type() env['CONTENT_TYPE'] = self.headers.get_default_type()
else: else:
env[r'CONTENT_TYPE'] = self.headers.get_content_type() env['CONTENT_TYPE'] = self.headers.get_content_type()
length = self.headers.get(r'content-length') length = self.headers.get('content-length')
else: else:
if self.headers.typeheader is None: if self.headers.typeheader is None:
env[r'CONTENT_TYPE'] = self.headers.type env['CONTENT_TYPE'] = self.headers.type
else: else:
env[r'CONTENT_TYPE'] = self.headers.typeheader env['CONTENT_TYPE'] = self.headers.typeheader
length = self.headers.getheader(r'content-length') length = self.headers.getheader('content-length')
if length: if length:
env[r'CONTENT_LENGTH'] = length env['CONTENT_LENGTH'] = length
for header in [ for header in [
h h
for h in self.headers.keys() for h in self.headers.keys()
if h.lower() not in (r'content-type', r'content-length') if h.lower() not in ('content-type', 'content-length')
]: ]:
hkey = r'HTTP_' + header.replace(r'-', r'_').upper() hkey = 'HTTP_' + header.replace('-', '_').upper()
hval = self.headers.get(header) hval = self.headers.get(header)
hval = hval.replace(r'\n', r'').strip() hval = hval.replace('\n', '').strip()
if hval: if hval:
env[hkey] = hval env[hkey] = hval
env[r'SERVER_PROTOCOL'] = self.request_version env['SERVER_PROTOCOL'] = self.request_version
env[r'wsgi.version'] = (1, 0) env['wsgi.version'] = (1, 0)
env[r'wsgi.url_scheme'] = pycompat.sysstr(self.url_scheme) env['wsgi.url_scheme'] = pycompat.sysstr(self.url_scheme)
if env.get(r'HTTP_EXPECT', b'').lower() == b'100-continue': if env.get('HTTP_EXPECT', b'').lower() == b'100-continue':
self.rfile = common.continuereader(self.rfile, self.wfile.write) self.rfile = common.continuereader(self.rfile, self.wfile.write)
env[r'wsgi.input'] = self.rfile env['wsgi.input'] = self.rfile
env[r'wsgi.errors'] = _error_logger(self) env['wsgi.errors'] = _error_logger(self)
env[r'wsgi.multithread'] = isinstance( env['wsgi.multithread'] = isinstance(
self.server, socketserver.ThreadingMixIn self.server, socketserver.ThreadingMixIn
) )
if util.safehasattr(socketserver, b'ForkingMixIn'): if util.safehasattr(socketserver, b'ForkingMixIn'):
env[r'wsgi.multiprocess'] = isinstance( env['wsgi.multiprocess'] = isinstance(
self.server, socketserver.ForkingMixIn self.server, socketserver.ForkingMixIn
) )
else: else:
env[r'wsgi.multiprocess'] = False env['wsgi.multiprocess'] = False
env[r'wsgi.run_once'] = 0 env['wsgi.run_once'] = 0
wsgiref.validate.check_environ(env) wsgiref.validate.check_environ(env)
self.saved_status = None self.saved_status = None
self.saved_headers = [] self.saved_headers = []
self.length = None self.length = None
self._chunked = None self._chunked = None
for chunk in self.server.application(env, self._start_response): for chunk in self.server.application(env, self._start_response):
) )
saved_status = self.saved_status.split(None, 1) saved_status = self.saved_status.split(None, 1)
saved_status[0] = int(saved_status[0]) saved_status[0] = int(saved_status[0])
self.send_response(*saved_status) self.send_response(*saved_status)
self.length = None self.length = None
self._chunked = False self._chunked = False
for h in self.saved_headers: for h in self.saved_headers:
self.send_header(*h) self.send_header(*h)
if h[0].lower() == r'content-length': if h[0].lower() == 'content-length':
self.length = int(h[1]) self.length = int(h[1])
if self.length is None and saved_status[0] != common.HTTP_NOT_MODIFIED: if self.length is None and saved_status[0] != common.HTTP_NOT_MODIFIED:
self._chunked = ( self._chunked = (
not self.close_connection not self.close_connection and self.request_version == 'HTTP/1.1'
and self.request_version == r'HTTP/1.1'
) )
if self._chunked: if self._chunked:
self.send_header(r'Transfer-Encoding', r'chunked') self.send_header('Transfer-Encoding', 'chunked')
else: else:
self.send_header(r'Connection', r'close') self.send_header('Connection', 'close')
self.end_headers() self.end_headers()
self.sent_headers = True self.sent_headers = True
def _start_response(self, http_status, headers, exc_info=None): def _start_response(self, http_status, headers, exc_info=None):
assert isinstance(http_status, str) assert isinstance(http_status, str)
code, msg = http_status.split(None, 1) code, msg = http_status.split(None, 1)
code = int(code) code = int(code)
self.saved_status = http_status self.saved_status = http_status
bad_headers = (r'connection', r'transfer-encoding') bad_headers = ('connection', 'transfer-encoding')
self.saved_headers = [ self.saved_headers = [
h for h in headers if h[0].lower() not in bad_headers h for h in headers if h[0].lower() not in bad_headers
] ]
return self._write return self._write
def _write(self, data): def _write(self, data):
if not self.saved_status: if not self.saved_status:
raise AssertionError(b"data written before start_response() called") raise AssertionError(b"data written before start_response() called")

mercurial/hgweb/wsgicgi.py

from . import common from . import common
def launch(application): def launch(application):
procutil.setbinary(procutil.stdin) procutil.setbinary(procutil.stdin)
procutil.setbinary(procutil.stdout) procutil.setbinary(procutil.stdout)
environ = dict(pycompat.iteritems(os.environ)) # re-exports environ = dict(pycompat.iteritems(os.environ)) # re-exports
environ.setdefault(r'PATH_INFO', b'') environ.setdefault('PATH_INFO', b'')
if environ.get(r'SERVER_SOFTWARE', r'').startswith(r'Microsoft-IIS'): if environ.get('SERVER_SOFTWARE', '').startswith('Microsoft-IIS'):
# IIS includes script_name in PATH_INFO # IIS includes script_name in PATH_INFO
scriptname = environ[r'SCRIPT_NAME'] scriptname = environ['SCRIPT_NAME']
if environ[r'PATH_INFO'].startswith(scriptname): if environ['PATH_INFO'].startswith(scriptname):
environ[r'PATH_INFO'] = environ[r'PATH_INFO'][len(scriptname) :] environ['PATH_INFO'] = environ['PATH_INFO'][len(scriptname) :]
stdin = procutil.stdin stdin = procutil.stdin
if environ.get(r'HTTP_EXPECT', r'').lower() == r'100-continue': if environ.get('HTTP_EXPECT', '').lower() == '100-continue':
stdin = common.continuereader(stdin, procutil.stdout.write) stdin = common.continuereader(stdin, procutil.stdout.write)
environ[r'wsgi.input'] = stdin environ['wsgi.input'] = stdin
environ[r'wsgi.errors'] = procutil.stderr environ['wsgi.errors'] = procutil.stderr
environ[r'wsgi.version'] = (1, 0) environ['wsgi.version'] = (1, 0)
environ[r'wsgi.multithread'] = False environ['wsgi.multithread'] = False
environ[r'wsgi.multiprocess'] = True environ['wsgi.multiprocess'] = True
environ[r'wsgi.run_once'] = True environ['wsgi.run_once'] = True
if environ.get(r'HTTPS', r'off').lower() in (r'on', r'1', r'yes'): if environ.get('HTTPS', 'off').lower() in ('on', '1', 'yes'):
environ[r'wsgi.url_scheme'] = r'https' environ['wsgi.url_scheme'] = 'https'
else: else:
environ[r'wsgi.url_scheme'] = r'http' environ['wsgi.url_scheme'] = 'http'
headers_set = [] headers_set = []
headers_sent = [] headers_sent = []
out = procutil.stdout out = procutil.stdout
def write(data): def write(data):
if not headers_set: if not headers_set:
raise AssertionError(b"write() before start_response()") raise AssertionError(b"write() before start_response()")

mercurial/httppeer.py

# HTTP Headers are ASCII. Python 3 requires them to be unicodes, # HTTP Headers are ASCII. Python 3 requires them to be unicodes,
# not bytes. This function always takes bytes in as arguments. # not bytes. This function always takes bytes in as arguments.
fmt = pycompat.strurl(header) + r'-%s' fmt = pycompat.strurl(header) + r'-%s'
# Note: it is *NOT* a bug that the last bit here is a bytestring # Note: it is *NOT* a bug that the last bit here is a bytestring
# and not a unicode: we're just getting the encoded length anyway, # and not a unicode: we're just getting the encoded length anyway,
# and using an r-string to make it portable between Python 2 and 3 # and using an r-string to make it portable between Python 2 and 3
# doesn't work because then the \r is a literal backslash-r # doesn't work because then the \r is a literal backslash-r
# instead of a carriage return. # instead of a carriage return.
valuelen = limit - len(fmt % r'000') - len(b': \r\n') valuelen = limit - len(fmt % '000') - len(b': \r\n')
result = [] result = []
n = 0 n = 0
for i in pycompat.xrange(0, len(value), valuelen): for i in pycompat.xrange(0, len(value), valuelen):
n += 1 n += 1
result.append((fmt % str(n), pycompat.strurl(value[i : i + valuelen]))) result.append((fmt % str(n), pycompat.strurl(value[i : i + valuelen])))
return result return result
else: else:
if isinstance(data, bytes): if isinstance(data, bytes):
i = io.BytesIO(data) i = io.BytesIO(data)
i.length = len(data) i.length = len(data)
data = i data = i
argsio = io.BytesIO(strargs) argsio = io.BytesIO(strargs)
argsio.length = len(strargs) argsio.length = len(strargs)
data = _multifile(argsio, data) data = _multifile(argsio, data)
headers[r'X-HgArgs-Post'] = len(strargs) headers['X-HgArgs-Post'] = len(strargs)
elif args: elif args:
# Calling self.capable() can infinite loop if we are calling # Calling self.capable() can infinite loop if we are calling
# "capabilities". But that command should never accept wire # "capabilities". But that command should never accept wire
# protocol arguments. So this should never happen. # protocol arguments. So this should never happen.
assert cmd != b'capabilities' assert cmd != b'capabilities'
httpheader = capablefn(b'httpheader') httpheader = capablefn(b'httpheader')
if httpheader: if httpheader:
headersize = int(httpheader.split(b',', 1)[0]) headersize = int(httpheader.split(b',', 1)[0])
qs = b'?%s' % urlreq.urlencode(q) qs = b'?%s' % urlreq.urlencode(q)
cu = b"%s%s" % (repobaseurl, qs) cu = b"%s%s" % (repobaseurl, qs)
size = 0 size = 0
if util.safehasattr(data, b'length'): if util.safehasattr(data, b'length'):
size = data.length size = data.length
elif data is not None: elif data is not None:
size = len(data) size = len(data)
if data is not None and r'Content-Type' not in headers: if data is not None and 'Content-Type' not in headers:
headers[r'Content-Type'] = r'application/mercurial-0.1' headers['Content-Type'] = 'application/mercurial-0.1'
# Tell the server we accept application/mercurial-0.2 and multiple # Tell the server we accept application/mercurial-0.2 and multiple
# compression formats if the server is capable of emitting those # compression formats if the server is capable of emitting those
# payloads. # payloads.
# Note: Keep this set empty by default, as client advertisement of # Note: Keep this set empty by default, as client advertisement of
# protocol parameters should only occur after the handshake. # protocol parameters should only occur after the handshake.
protoparams = set() protoparams = set()
protoheaders = encodevalueinheaders( protoheaders = encodevalueinheaders(
b' '.join(sorted(protoparams)), b'X-HgProto', headersize or 1024 b' '.join(sorted(protoparams)), b'X-HgProto', headersize or 1024
) )
for header, value in protoheaders: for header, value in protoheaders:
headers[header] = value headers[header] = value
varyheaders = [] varyheaders = []
for header in headers: for header in headers:
if header.lower().startswith(r'x-hg'): if header.lower().startswith('x-hg'):
varyheaders.append(header) varyheaders.append(header)
if varyheaders: if varyheaders:
headers[r'Vary'] = r','.join(sorted(varyheaders)) headers['Vary'] = ','.join(sorted(varyheaders))
req = requestbuilder(pycompat.strurl(cu), data, headers) req = requestbuilder(pycompat.strurl(cu), data, headers)
if data is not None: if data is not None:
ui.debug(b"sending %d bytes\n" % size) ui.debug(b"sending %d bytes\n" % size)
req.add_unredirected_header(r'Content-Length', r'%d' % size) req.add_unredirected_header('Content-Length', '%d' % size)
return req, cu, qs return req, cu, qs
def _reqdata(req): def _reqdata(req):
"""Get request data, if any. If no data, returns None.""" """Get request data, if any. If no data, returns None."""
if pycompat.ispy3: if pycompat.ispy3:
return req.data return req.data
qsdropped = True qsdropped = True
if baseurl.rstrip(b'/') != respurl.rstrip(b'/'): if baseurl.rstrip(b'/') != respurl.rstrip(b'/'):
redirected = True redirected = True
if not ui.quiet: if not ui.quiet:
ui.warn(_(b'real URL is %s\n') % respurl) ui.warn(_(b'real URL is %s\n') % respurl)
try: try:
proto = pycompat.bytesurl(resp.getheader(r'content-type', r'')) proto = pycompat.bytesurl(resp.getheader('content-type', ''))
except AttributeError: except AttributeError:
proto = pycompat.bytesurl(resp.headers.get(r'content-type', r'')) proto = pycompat.bytesurl(resp.headers.get('content-type', ''))
safeurl = util.hidepassword(baseurl) safeurl = util.hidepassword(baseurl)
if proto.startswith(b'application/hg-error'): if proto.startswith(b'application/hg-error'):
raise error.OutOfBandError(resp.read()) raise error.OutOfBandError(resp.read())
# Pre 1.0 versions of Mercurial used text/plain and # Pre 1.0 versions of Mercurial used text/plain and
# application/hg-changegroup. We don't support such old servers. # application/hg-changegroup. We don't support such old servers.
if not proto.startswith(b'application/mercurial-'): if not proto.startswith(b'application/mercurial-'):
types = [b""] types = [b""]
for x in types: for x in types:
if x in bundle2.bundletypes: if x in bundle2.bundletypes:
type = x type = x
break break
tempname = bundle2.writebundle(self.ui, cg, None, type) tempname = bundle2.writebundle(self.ui, cg, None, type)
fp = httpconnection.httpsendfile(self.ui, tempname, b"rb") fp = httpconnection.httpsendfile(self.ui, tempname, b"rb")
headers = {r'Content-Type': r'application/mercurial-0.1'} headers = {'Content-Type': 'application/mercurial-0.1'}
try: try:
r = self._call(cmd, data=fp, headers=headers, **args) r = self._call(cmd, data=fp, headers=headers, **args)
vals = r.split(b'\n', 1) vals = r.split(b'\n', 1)
if len(vals) < 2: if len(vals) < 2:
raise error.ResponseError(_(b"unexpected response:"), r) raise error.ResponseError(_(b"unexpected response:"), r)
return vals return vals
except urlerr.httperror: except urlerr.httperror:
fd, filename = pycompat.mkstemp(prefix=b"hg-bundle-", suffix=b".hg") fd, filename = pycompat.mkstemp(prefix=b"hg-bundle-", suffix=b".hg")
with os.fdopen(fd, "wb") as fh: with os.fdopen(fd, "wb") as fh:
d = fp.read(4096) d = fp.read(4096)
while d: while d:
fh.write(d) fh.write(d)
d = fp.read(4096) d = fp.read(4096)
# start http push # start http push
with httpconnection.httpsendfile(self.ui, filename, b"rb") as fp_: with httpconnection.httpsendfile(self.ui, filename, b"rb") as fp_:
headers = {r'Content-Type': r'application/mercurial-0.1'} headers = {'Content-Type': 'application/mercurial-0.1'}
return self._callstream(cmd, data=fp_, headers=headers, **args) return self._callstream(cmd, data=fp_, headers=headers, **args)
finally: finally:
if filename is not None: if filename is not None:
os.unlink(filename) os.unlink(filename)
def _callcompressable(self, cmd, **args): def _callcompressable(self, cmd, **args):
return self._callstream(cmd, _compressible=True, **args) return self._callstream(cmd, _compressible=True, **args)
handler.callcommand(command, args, f, redirect=redirect) handler.callcommand(command, args, f, redirect=redirect)
) )
# TODO stream this. # TODO stream this.
body = b''.join(map(bytes, handler.flushcommands())) body = b''.join(map(bytes, handler.flushcommands()))
# TODO modify user-agent to reflect v2 # TODO modify user-agent to reflect v2
headers = { headers = {
r'Accept': wireprotov2server.FRAMINGTYPE, 'Accept': wireprotov2server.FRAMINGTYPE,
r'Content-Type': wireprotov2server.FRAMINGTYPE, 'Content-Type': wireprotov2server.FRAMINGTYPE,
} }
req = requestbuilder(pycompat.strurl(url), body, headers) req = requestbuilder(pycompat.strurl(url), body, headers)
req.add_unredirected_header(r'Content-Length', r'%d' % len(body)) req.add_unredirected_header('Content-Length', '%d' % len(body))
try: try:
res = opener.open(req) res = opener.open(req)
except urlerr.httperror as e: except urlerr.httperror as e:
if e.code == 401: if e.code == 401:
raise error.Abort(_(b'authorization failed')) raise error.Abort(_(b'authorization failed'))
raise raise
# X-HgUpgrade-* header with a list of supported APIs and an # X-HgUpgrade-* header with a list of supported APIs and an
# X-HgProto-* header advertising which serializing formats it supports. # X-HgProto-* header advertising which serializing formats it supports.
# We only support the HTTP version 2 transport and CBOR responses for # We only support the HTTP version 2 transport and CBOR responses for
# now. # now.
advertisev2 = ui.configbool(b'experimental', b'httppeer.advertise-v2') advertisev2 = ui.configbool(b'experimental', b'httppeer.advertise-v2')
if advertisev2: if advertisev2:
args[b'headers'] = { args[b'headers'] = {
r'X-HgProto-1': r'cbor', 'X-HgProto-1': 'cbor',
} }
args[b'headers'].update( args[b'headers'].update(
encodevalueinheaders( encodevalueinheaders(
b' '.join(sorted(API_PEERS)), b' '.join(sorted(API_PEERS)),
b'X-HgUpgrade', b'X-HgUpgrade',
# We don't know the header limit this early. # We don't know the header limit this early.
# So make it small. # So make it small.

mercurial/i18n.py

# ctypes not found or unknown langid # ctypes not found or unknown langid
pass pass
_ugettext = None _ugettext = None
def setdatapath(datapath): def setdatapath(datapath):
datapath = pycompat.fsdecode(datapath) datapath = pycompat.fsdecode(datapath)
localedir = os.path.join(datapath, r'locale') localedir = os.path.join(datapath, 'locale')
t = gettextmod.translation(r'hg', localedir, _languages, fallback=True) t = gettextmod.translation('hg', localedir, _languages, fallback=True)
global _ugettext global _ugettext
try: try:
_ugettext = t.ugettext _ugettext = t.ugettext
except AttributeError: except AttributeError:
_ugettext = t.gettext _ugettext = t.gettext
_msgcache = {} # encoding: {message: translation} _msgcache = {} # encoding: {message: translation}

mercurial/keepalive.py

# What follows mostly reimplements HTTPConnection.request() # What follows mostly reimplements HTTPConnection.request()
# except it adds self.parent.addheaders in the mix and sends headers # except it adds self.parent.addheaders in the mix and sends headers
# in a deterministic order (to make testing easier). # in a deterministic order (to make testing easier).
headers = util.sortdict(self.parent.addheaders) headers = util.sortdict(self.parent.addheaders)
headers.update(sorted(req.headers.items())) headers.update(sorted(req.headers.items()))
headers.update(sorted(req.unredirected_hdrs.items())) headers.update(sorted(req.unredirected_hdrs.items()))
headers = util.sortdict((n.lower(), v) for n, v in headers.items()) headers = util.sortdict((n.lower(), v) for n, v in headers.items())
skipheaders = {} skipheaders = {}
for n in (r'host', r'accept-encoding'): for n in ('host', 'accept-encoding'):
if n in headers: if n in headers:
skipheaders[r'skip_' + n.replace(r'-', r'_')] = 1 skipheaders['skip_' + n.replace('-', '_')] = 1
try: try:
if urllibcompat.hasdata(req): if urllibcompat.hasdata(req):
data = urllibcompat.getdata(req) data = urllibcompat.getdata(req)
h.putrequest( h.putrequest(
req.get_method(), req.get_method(),
urllibcompat.getselector(req), urllibcompat.getselector(req),
**skipheaders **skipheaders
) )
if r'content-type' not in headers: if 'content-type' not in headers:
h.putheader( h.putheader(
r'Content-type', r'application/x-www-form-urlencoded' 'Content-type', 'application/x-www-form-urlencoded'
) )
if r'content-length' not in headers: if 'content-length' not in headers:
h.putheader(r'Content-length', r'%d' % len(data)) h.putheader('Content-length', '%d' % len(data))
else: else:
h.putrequest( h.putrequest(
req.get_method(), req.get_method(),
urllibcompat.getselector(req), urllibcompat.getselector(req),
**skipheaders **skipheaders
) )
except socket.error as err: except socket.error as err:
raise urlerr.urlerror(err) raise urlerr.urlerror(err)
# the read method wraps the original to accommodate buffering, # the read method wraps the original to accommodate buffering,
# although read() never adds to the buffer. # although read() never adds to the buffer.
# Both readline and readlines have been stolen with almost no # Both readline and readlines have been stolen with almost no
# modification from socket.py # modification from socket.py
def __init__(self, sock, debuglevel=0, strict=0, method=None): def __init__(self, sock, debuglevel=0, strict=0, method=None):
extrakw = {} extrakw = {}
if not pycompat.ispy3: if not pycompat.ispy3:
extrakw[r'strict'] = True extrakw['strict'] = True
extrakw[r'buffering'] = True extrakw['buffering'] = True
httplib.HTTPResponse.__init__( httplib.HTTPResponse.__init__(
self, sock, debuglevel=debuglevel, method=method, **extrakw self, sock, debuglevel=debuglevel, method=method, **extrakw
) )
self.fileno = sock.fileno self.fileno = sock.fileno
self.code = None self.code = None
self.receivedbytescount = 0 self.receivedbytescount = 0
self._rbuf = b'' self._rbuf = b''
self._rbufsize = 8096 self._rbufsize = 8096

mercurial/linelog.py

class _jge(_llinstruction): class _jge(_llinstruction):
"""If the current rev is greater than or equal to op1, jump to op2.""" """If the current rev is greater than or equal to op1, jump to op2."""
def __init__(self, op1, op2): def __init__(self, op1, op2):
self._cmprev = op1 self._cmprev = op1
self._target = op2 self._target = op2
def __str__(self): def __str__(self):
return r'JGE %d %d' % (self._cmprev, self._target) return 'JGE %d %d' % (self._cmprev, self._target)
def __eq__(self, other): def __eq__(self, other):
return ( return (
type(self) == type(other) type(self) == type(other)
and self._cmprev == other._cmprev and self._cmprev == other._cmprev
and self._target == other._target and self._target == other._target
) )
"""Unconditional jumps are expressed as a JGE with op1 set to 0.""" """Unconditional jumps are expressed as a JGE with op1 set to 0."""
def __init__(self, op1, op2): def __init__(self, op1, op2):
if op1 != 0: if op1 != 0:
raise LineLogError(b"malformed JUMP, op1 must be 0, got %d" % op1) raise LineLogError(b"malformed JUMP, op1 must be 0, got %d" % op1)
self._target = op2 self._target = op2
def __str__(self): def __str__(self):
return r'JUMP %d' % (self._target) return 'JUMP %d' % (self._target)
def __eq__(self, other): def __eq__(self, other):
return type(self) == type(other) and self._target == other._target return type(self) == type(other) and self._target == other._target
def encode(self): def encode(self):
return _llentry.pack(0, self._target) return _llentry.pack(0, self._target)
def execute(self, rev, pc, emit): def execute(self, rev, pc, emit):
class _jl(_llinstruction): class _jl(_llinstruction):
"""If the current rev is less than op1, jump to op2.""" """If the current rev is less than op1, jump to op2."""
def __init__(self, op1, op2): def __init__(self, op1, op2):
self._cmprev = op1 self._cmprev = op1
self._target = op2 self._target = op2
def __str__(self): def __str__(self):
return r'JL %d %d' % (self._cmprev, self._target) return 'JL %d %d' % (self._cmprev, self._target)
def __eq__(self, other): def __eq__(self, other):
return ( return (
type(self) == type(other) type(self) == type(other)
and self._cmprev == other._cmprev and self._cmprev == other._cmprev
and self._target == other._target and self._target == other._target
) )
def __init__(self, op1, op2): def __init__(self, op1, op2):
# This line was introduced by this revision number. # This line was introduced by this revision number.
self._rev = op1 self._rev = op1
# This line had the specified line number in the introducing revision. # This line had the specified line number in the introducing revision.
self._origlineno = op2 self._origlineno = op2
def __str__(self): def __str__(self):
return r'LINE %d %d' % (self._rev, self._origlineno) return 'LINE %d %d' % (self._rev, self._origlineno)
def __eq__(self, other): def __eq__(self, other):
return ( return (
type(self) == type(other) type(self) == type(other)
and self._rev == other._rev and self._rev == other._rev
and self._origlineno == other._origlineno and self._origlineno == other._origlineno
) )
def __repr__(self): def __repr__(self):
return b'<linelog at %s: maxrev=%d size=%d>' % ( return b'<linelog at %s: maxrev=%d size=%d>' % (
hex(id(self)), hex(id(self)),
self._maxrev, self._maxrev,
len(self._program), len(self._program),
) )
def debugstr(self): def debugstr(self):
fmt = r'%%%dd %%s' % len(str(len(self._program))) fmt = '%%%dd %%s' % len(str(len(self._program)))
return pycompat.sysstr(b'\n').join( return pycompat.sysstr(b'\n').join(
fmt % (idx, i) for idx, i in enumerate(self._program[1:], 1) fmt % (idx, i) for idx, i in enumerate(self._program[1:], 1)
) )
@classmethod @classmethod
def fromdata(cls, buf): def fromdata(cls, buf):
if len(buf) % _llentry.size != 0: if len(buf) % _llentry.size != 0:
raise LineLogError( raise LineLogError(

mercurial/localrepo.py

# written, even if they're a subset of another kind of cache that # written, even if they're a subset of another kind of cache that
# *has* been used). # *has* been used).
for filt in repoview.filtertable.keys(): for filt in repoview.filtertable.keys():
filtered = self.filtered(filt) filtered = self.filtered(filt)
filtered.branchmap().write(filtered) filtered.branchmap().write(filtered)
def invalidatecaches(self): def invalidatecaches(self):
if r'_tagscache' in vars(self): if '_tagscache' in vars(self):
# can't use delattr on proxy # can't use delattr on proxy
del self.__dict__[r'_tagscache'] del self.__dict__['_tagscache']
self._branchcaches.clear() self._branchcaches.clear()
self.invalidatevolatilesets() self.invalidatevolatilesets()
self._sparsesignaturecache.clear() self._sparsesignaturecache.clear()
def invalidatevolatilesets(self): def invalidatevolatilesets(self):
self.filteredrevcache.clear() self.filteredrevcache.clear()
obsolete.clearobscaches(self) obsolete.clearobscaches(self)
def invalidatedirstate(self): def invalidatedirstate(self):
'''Invalidates the dirstate, causing the next call to dirstate '''Invalidates the dirstate, causing the next call to dirstate
to check if it was modified since the last time it was read, to check if it was modified since the last time it was read,
rereading it if it has. rereading it if it has.
This is different to dirstate.invalidate() that it doesn't always This is different to dirstate.invalidate() that it doesn't always
rereads the dirstate. Use dirstate.invalidate() if you want to rereads the dirstate. Use dirstate.invalidate() if you want to
explicitly read the dirstate again (i.e. restoring it to a previous explicitly read the dirstate again (i.e. restoring it to a previous
known good state).''' known good state).'''
if hasunfilteredcache(self, r'dirstate'): if hasunfilteredcache(self, 'dirstate'):
for k in self.dirstate._filecache: for k in self.dirstate._filecache:
try: try:
delattr(self.dirstate, k) delattr(self.dirstate, k)
except AttributeError: except AttributeError:
pass pass
delattr(self.unfiltered(), r'dirstate') delattr(self.unfiltered(), 'dirstate')
def invalidate(self, clearfilecache=False): def invalidate(self, clearfilecache=False):
'''Invalidates both store and non-store parts other than dirstate '''Invalidates both store and non-store parts other than dirstate
If a transaction is running, invalidation of store is omitted, If a transaction is running, invalidation of store is omitted,
because discarding in-memory changes might cause inconsistency because discarding in-memory changes might cause inconsistency
(e.g. incomplete fncache causes unintentional failure, but (e.g. incomplete fncache causes unintentional failure, but
redundant one doesn't). redundant one doesn't).
self.invalidate() self.invalidate()
self.invalidatedirstate() self.invalidatedirstate()
@unfilteredmethod @unfilteredmethod
def _refreshfilecachestats(self, tr): def _refreshfilecachestats(self, tr):
"""Reload stats of cached files so that they are flagged as valid""" """Reload stats of cached files so that they are flagged as valid"""
for k, ce in self._filecache.items(): for k, ce in self._filecache.items():
k = pycompat.sysstr(k) k = pycompat.sysstr(k)
if k == r'dirstate' or k not in self.__dict__: if k == 'dirstate' or k not in self.__dict__:
continue continue
ce.refresh() ce.refresh()
def _lock( def _lock(
self, self,
vfs, vfs,
lockname, lockname,
wait, wait,
def pushkey(self, namespace, key, old, new): def pushkey(self, namespace, key, old, new):
try: try:
tr = self.currenttransaction() tr = self.currenttransaction()
hookargs = {} hookargs = {}
if tr is not None: if tr is not None:
hookargs.update(tr.hookargs) hookargs.update(tr.hookargs)
hookargs = pycompat.strkwargs(hookargs) hookargs = pycompat.strkwargs(hookargs)
hookargs[r'namespace'] = namespace hookargs['namespace'] = namespace
hookargs[r'key'] = key hookargs['key'] = key
hookargs[r'old'] = old hookargs['old'] = old
hookargs[r'new'] = new hookargs['new'] = new
self.hook(b'prepushkey', throw=True, **hookargs) self.hook(b'prepushkey', throw=True, **hookargs)
except error.HookAbort as exc: except error.HookAbort as exc:
self.ui.write_err(_(b"pushkey-abort: %s\n") % exc) self.ui.write_err(_(b"pushkey-abort: %s\n") % exc)
if exc.hint: if exc.hint:
self.ui.write_err(_(b"(%s)\n") % exc.hint) self.ui.write_err(_(b"(%s)\n") % exc.hint)
return False return False
self.ui.debug(b'pushing key for "%s:%s"\n' % (namespace, key)) self.ui.debug(b'pushing key for "%s:%s"\n' % (namespace, key))
ret = pushkey.push(self, namespace, key, old, new) ret = pushkey.push(self, namespace, key, old, new)
# Our strategy is to replace the type of the object with one that # Our strategy is to replace the type of the object with one that
# has all attribute lookups result in error. # has all attribute lookups result in error.
# #
# But we have to allow the close() method because some constructors # But we have to allow the close() method because some constructors
# of repos call close() on repo references. # of repos call close() on repo references.
class poisonedrepository(object): class poisonedrepository(object):
def __getattribute__(self, item): def __getattribute__(self, item):
if item == r'close': if item == 'close':
return object.__getattribute__(self, item) return object.__getattribute__(self, item)
raise error.ProgrammingError( raise error.ProgrammingError(
b'repo instances should not be used after unshare' b'repo instances should not be used after unshare'
) )
def close(self): def close(self):
pass pass
# We may have a repoview, which intercepts __setattr__. So be sure # We may have a repoview, which intercepts __setattr__. So be sure
# we operate at the lowest level possible. # we operate at the lowest level possible.
object.__setattr__(repo, r'__class__', poisonedrepository) object.__setattr__(repo, '__class__', poisonedrepository)

mercurial/lsprof.py

if v is None: if v is None:
continue continue
if not isinstance(getattr(v, '__file__', None), str): if not isinstance(getattr(v, '__file__', None), str):
continue continue
if v.__file__.startswith(code.co_filename): if v.__file__.startswith(code.co_filename):
mname = _fn2mod[code.co_filename] = k mname = _fn2mod[code.co_filename] = k
break break
else: else:
mname = _fn2mod[code.co_filename] = r'<%s>' % code.co_filename mname = _fn2mod[code.co_filename] = '<%s>' % code.co_filename
res = r'%s:%d(%s)' % (mname, code.co_firstlineno, code.co_name) res = '%s:%d(%s)' % (mname, code.co_firstlineno, code.co_name)
if sys.version_info.major >= 3: if sys.version_info.major >= 3:
res = res.encode('latin-1') res = res.encode('latin-1')
return res return res

mercurial/mail.py

new_socket = socket.create_connection((host, port), timeout) new_socket = socket.create_connection((host, port), timeout)
new_socket = sslutil.wrapsocket( new_socket = sslutil.wrapsocket(
new_socket, new_socket,
self.keyfile, self.keyfile,
self.certfile, self.certfile,
ui=self._ui, ui=self._ui,
serverhostname=self._host, serverhostname=self._host,
) )
self.file = new_socket.makefile(r'rb') self.file = new_socket.makefile('rb')
return new_socket return new_socket
def _pyhastls(): def _pyhastls():
"""Returns true iff Python has TLS support, false otherwise.""" """Returns true iff Python has TLS support, false otherwise."""
try: try:
import ssl import ssl
) )
def _mbox(mbox, sender, recipients, msg): def _mbox(mbox, sender, recipients, msg):
'''write mails to mbox''' '''write mails to mbox'''
fp = open(mbox, b'ab+') fp = open(mbox, b'ab+')
# Should be time.asctime(), but Windows prints 2-characters day # Should be time.asctime(), but Windows prints 2-characters day
# of month instead of one. Make them print the same thing. # of month instead of one. Make them print the same thing.
date = time.strftime(r'%a %b %d %H:%M:%S %Y', time.localtime()) date = time.strftime('%a %b %d %H:%M:%S %Y', time.localtime())
fp.write( fp.write(
b'From %s %s\n' b'From %s %s\n'
% (encoding.strtolocal(sender), encoding.strtolocal(date)) % (encoding.strtolocal(sender), encoding.strtolocal(date))
) )
fp.write(msg) fp.write(msg)
fp.write(b'\n\n') fp.write(b'\n\n')
fp.close() fp.close()
return _addressencode(ui, name, encoding.strtolocal(addr), charsets) return _addressencode(ui, name, encoding.strtolocal(addr), charsets)
def addrlistencode(ui, addrs, charsets=None, display=False): def addrlistencode(ui, addrs, charsets=None, display=False):
'''Turns a list of addresses into a list of RFC-2047 compliant headers. '''Turns a list of addresses into a list of RFC-2047 compliant headers.
A single element of input list may contain multiple addresses, but output A single element of input list may contain multiple addresses, but output
always has one address per item''' always has one address per item'''
for a in addrs: for a in addrs:
assert isinstance(a, bytes), r'%r unexpectedly not a bytestr' % a assert isinstance(a, bytes), '%r unexpectedly not a bytestr' % a
if display: if display:
return [a.strip() for a in addrs if a.strip()] return [a.strip() for a in addrs if a.strip()]
result = [] result = []
for name, addr in email.utils.getaddresses( for name, addr in email.utils.getaddresses(
[encoding.strfromlocal(a) for a in addrs] [encoding.strfromlocal(a) for a in addrs]
): ):
if name or addr: if name or addr:
Generator = email.generator.BytesGenerator Generator = email.generator.BytesGenerator
def parse(fp): def parse(fp):
ep = email.parser.Parser() ep = email.parser.Parser()
# disable the "universal newlines" mode, which isn't binary safe. # disable the "universal newlines" mode, which isn't binary safe.
# I have no idea if ascii/surrogateescape is correct, but that's # I have no idea if ascii/surrogateescape is correct, but that's
# what the standard Python email parser does. # what the standard Python email parser does.
fp = io.TextIOWrapper( fp = io.TextIOWrapper(
fp, encoding=r'ascii', errors=r'surrogateescape', newline=chr(10) fp, encoding='ascii', errors='surrogateescape', newline=chr(10)
) )
try: try:
return ep.parse(fp) return ep.parse(fp)
finally: finally:
fp.detach() fp.detach()
def parsebytes(data): def parsebytes(data):
ep = email.parser.BytesParser() ep = email.parser.BytesParser()

mercurial/manifest.py

revlog, revlog,
util, util,
) )
from .interfaces import ( from .interfaces import (
repository, repository,
util as interfaceutil, util as interfaceutil,
) )
parsers = policy.importmod(r'parsers') parsers = policy.importmod('parsers')
propertycache = util.propertycache propertycache = util.propertycache
# Allow tests to more easily test the alternate path in manifestdict.fastdelta() # Allow tests to more easily test the alternate path in manifestdict.fastdelta()
FASTDELTA_TEXTDIFF_THRESHOLD = 1000 FASTDELTA_TEXTDIFF_THRESHOLD = 1000
def _parse(data): def _parse(data):
# This method does a little bit of excessive-looking # This method does a little bit of excessive-looking

mercurial/match.py

error, error,
pathutil, pathutil,
policy, policy,
pycompat, pycompat,
util, util,
) )
from .utils import stringutil from .utils import stringutil
rustmod = policy.importrust(r'filepatterns') rustmod = policy.importrust('filepatterns')
allpatternkinds = ( allpatternkinds = (
b're', b're',
b'glob', b'glob',
b'path', b'path',
b'relglob', b'relglob',
b'relpath', b'relpath',
b'relre', b'relre',

mercurial/mdiff.py

policy, policy,
pycompat, pycompat,
util, util,
) )
from .utils import dateutil from .utils import dateutil
_missing_newline_marker = b"\\ No newline at end of file\n" _missing_newline_marker = b"\\ No newline at end of file\n"
bdiff = policy.importmod(r'bdiff') bdiff = policy.importmod('bdiff')
mpatch = policy.importmod(r'mpatch') mpatch = policy.importmod('mpatch')
blocks = bdiff.blocks blocks = bdiff.blocks
fixws = bdiff.fixws fixws = bdiff.fixws
patches = mpatch.patches patches = mpatch.patches
patchedsize = mpatch.patchedsize patchedsize = mpatch.patchedsize
textdiff = bdiff.bdiff textdiff = bdiff.bdiff
splitnewlines = bdiff.splitnewlines splitnewlines = bdiff.splitnewlines

mercurial/obsolete.py

obsutil, obsutil,
phases, phases,
policy, policy,
pycompat, pycompat,
util, util,
) )
from .utils import dateutil from .utils import dateutil
parsers = policy.importmod(r'parsers') parsers = policy.importmod('parsers')
_pack = struct.pack _pack = struct.pack
_unpack = struct.unpack _unpack = struct.unpack
_calcsize = struct.calcsize _calcsize = struct.calcsize
propertycache = util.propertycache propertycache = util.propertycache
# Options for obsolescence # Options for obsolescence
createmarkersopt = b'createmarkers' createmarkersopt = b'createmarkers'
def __iter__(self): def __iter__(self):
return iter(self._all) return iter(self._all)
def __len__(self): def __len__(self):
return len(self._all) return len(self._all)
def __nonzero__(self): def __nonzero__(self):
if not self._cached(r'_all'): if not self._cached('_all'):
try: try:
return self.svfs.stat(b'obsstore').st_size > 1 return self.svfs.stat(b'obsstore').st_size > 1
except OSError as inst: except OSError as inst:
if inst.errno != errno.ENOENT: if inst.errno != errno.ENOENT:
raise raise
# just build an empty _all list if no obsstore exists, which # just build an empty _all list if no obsstore exists, which
# avoids further stat() syscalls # avoids further stat() syscalls
return bool(self._all) return bool(self._all)
date = dateutil.makedate() date = dateutil.makedate()
if len(prec) != 20: if len(prec) != 20:
raise ValueError(prec) raise ValueError(prec)
for succ in succs: for succ in succs:
if len(succ) != 20: if len(succ) != 20:
raise ValueError(succ) raise ValueError(succ)
if prec in succs: if prec in succs:
raise ValueError( raise ValueError(
r'in-marker cycle with %s' % pycompat.sysstr(node.hex(prec)) 'in-marker cycle with %s' % pycompat.sysstr(node.hex(prec))
) )
metadata = tuple(sorted(pycompat.iteritems(metadata))) metadata = tuple(sorted(pycompat.iteritems(metadata)))
for k, v in metadata: for k, v in metadata:
try: try:
# might be better to reject non-ASCII keys # might be better to reject non-ASCII keys
k.decode('utf-8') k.decode('utf-8')
v.decode('utf-8') v.decode('utf-8')
def _cached(self, attr): def _cached(self, attr):
return attr in self.__dict__ return attr in self.__dict__
def _addmarkers(self, markers, rawdata): def _addmarkers(self, markers, rawdata):
markers = list(markers) # to allow repeated iteration markers = list(markers) # to allow repeated iteration
self._data = self._data + rawdata self._data = self._data + rawdata
self._all.extend(markers) self._all.extend(markers)
if self._cached(r'successors'): if self._cached('successors'):
_addsuccessors(self.successors, markers) _addsuccessors(self.successors, markers)
if self._cached(r'predecessors'): if self._cached('predecessors'):
_addpredecessors(self.predecessors, markers) _addpredecessors(self.predecessors, markers)
if self._cached(r'children'): if self._cached('children'):
_addchildren(self.children, markers) _addchildren(self.children, markers)
_checkinvalidmarkers(markers) _checkinvalidmarkers(markers)
def relevantmarkers(self, nodes): def relevantmarkers(self, nodes):
"""return a set of all obsolescence markers relevant to a set of nodes. """return a set of all obsolescence markers relevant to a set of nodes.
"relevant" to a set of nodes mean: "relevant" to a set of nodes mean:
def makestore(ui, repo): def makestore(ui, repo):
"""Create an obsstore instance from a repo.""" """Create an obsstore instance from a repo."""
# read default format for new obsstore. # read default format for new obsstore.
# developer config: format.obsstore-version # developer config: format.obsstore-version
defaultformat = ui.configint(b'format', b'obsstore-version') defaultformat = ui.configint(b'format', b'obsstore-version')
# rely on obsstore class default when possible. # rely on obsstore class default when possible.
kwargs = {} kwargs = {}
if defaultformat is not None: if defaultformat is not None:
kwargs[r'defaultformat'] = defaultformat kwargs['defaultformat'] = defaultformat
readonly = not isenabled(repo, createmarkersopt) readonly = not isenabled(repo, createmarkersopt)
store = obsstore(repo.svfs, readonly=readonly, **kwargs) store = obsstore(repo.svfs, readonly=readonly, **kwargs)
if store and readonly: if store and readonly:
ui.warn( ui.warn(
_(b'obsolete feature not enabled but %i markers found!\n') _(b'obsolete feature not enabled but %i markers found!\n')
% len(list(store)) % len(list(store))
) )
return store return store

mercurial/patch.py

- branch, - branch,
- node, - node,
- p1, - p1,
- p2. - p2.
Any item can be missing from the dictionary. If filename is missing, Any item can be missing from the dictionary. If filename is missing,
fileobj did not contain a patch. Caller must unlink filename when done.''' fileobj did not contain a patch. Caller must unlink filename when done.'''
fd, tmpname = pycompat.mkstemp(prefix=b'hg-patch-') fd, tmpname = pycompat.mkstemp(prefix=b'hg-patch-')
tmpfp = os.fdopen(fd, r'wb') tmpfp = os.fdopen(fd, 'wb')
try: try:
yield _extract(ui, fileobj, tmpname, tmpfp) yield _extract(ui, fileobj, tmpname, tmpfp)
finally: finally:
tmpfp.close() tmpfp.close()
os.unlink(tmpname) os.unlink(tmpname)
def _extract(ui, fileobj, tmpname, tmpfp): def _extract(ui, fileobj, tmpname, tmpfp):
# attempt to detect the start of a patch # attempt to detect the start of a patch
# (this heuristic is borrowed from quilt) # (this heuristic is borrowed from quilt)
diffre = re.compile( diffre = re.compile(
br'^(?:Index:[ \t]|diff[ \t]-|RCS file: |' br'^(?:Index:[ \t]|diff[ \t]-|RCS file: |'
br'retrieving revision [0-9]+(\.[0-9]+)*$|' br'retrieving revision [0-9]+(\.[0-9]+)*$|'
br'---[ \t].*?^\+\+\+[ \t]|' br'---[ \t].*?^\+\+\+[ \t]|'
br'\*\*\*[ \t].*?^---[ \t])', br'\*\*\*[ \t].*?^---[ \t])',
re.MULTILINE | re.DOTALL, re.MULTILINE | re.DOTALL,
) )
data = {} data = {}
msg = mail.parse(fileobj) msg = mail.parse(fileobj)
subject = msg[r'Subject'] and mail.headdecode(msg[r'Subject']) subject = msg['Subject'] and mail.headdecode(msg['Subject'])
data[b'user'] = msg[r'From'] and mail.headdecode(msg[r'From']) data[b'user'] = msg['From'] and mail.headdecode(msg['From'])
if not subject and not data[b'user']: if not subject and not data[b'user']:
# Not an email, restore parsed headers if any # Not an email, restore parsed headers if any
subject = ( subject = (
b'\n'.join( b'\n'.join(
b': '.join(map(encoding.strtolocal, h)) for h in msg.items() b': '.join(map(encoding.strtolocal, h)) for h in msg.items()
) )
+ b'\n' + b'\n'
) )
# should try to parse msg['Date'] # should try to parse msg['Date']
parents = [] parents = []
nodeid = msg[r'X-Mercurial-Node'] nodeid = msg['X-Mercurial-Node']
if nodeid: if nodeid:
data[b'nodeid'] = nodeid = mail.headdecode(nodeid) data[b'nodeid'] = nodeid = mail.headdecode(nodeid)
ui.debug(b'Node ID: %s\n' % nodeid) ui.debug(b'Node ID: %s\n' % nodeid)
if subject: if subject:
if subject.startswith(b'[PATCH'): if subject.startswith(b'[PATCH'):
pend = subject.find(b']') pend = subject.find(b']')
if pend >= 0: if pend >= 0:
""" """
) )
(patchfd, patchfn) = pycompat.mkstemp( (patchfd, patchfn) = pycompat.mkstemp(
prefix=b"hg-editor-", suffix=b".diff" prefix=b"hg-editor-", suffix=b".diff"
) )
ncpatchfp = None ncpatchfp = None
try: try:
# Write the initial patch # Write the initial patch
f = util.nativeeolwriter(os.fdopen(patchfd, r'wb')) f = util.nativeeolwriter(os.fdopen(patchfd, 'wb'))
chunk.header.write(f) chunk.header.write(f)
chunk.write(f) chunk.write(f)
f.write( f.write(
b''.join( b''.join(
[b'# ' + i + b'\n' for i in phelp.splitlines()] [b'# ' + i + b'\n' for i in phelp.splitlines()]
) )
) )
f.close() f.close()
# Start the editor and wait for it to complete # Start the editor and wait for it to complete
editor = ui.geteditor() editor = ui.geteditor()
ret = ui.system( ret = ui.system(
b"%s \"%s\"" % (editor, patchfn), b"%s \"%s\"" % (editor, patchfn),
environ={b'HGUSER': ui.username()}, environ={b'HGUSER': ui.username()},
blockedtag=b'filterpatch', blockedtag=b'filterpatch',
) )
if ret != 0: if ret != 0:
ui.warn(_(b"editor exited with exit code %d\n") % ret) ui.warn(_(b"editor exited with exit code %d\n") % ret)
continue continue
# Remove comment lines # Remove comment lines
patchfp = open(patchfn, r'rb') patchfp = open(patchfn, 'rb')
ncpatchfp = stringio() ncpatchfp = stringio()
for line in util.iterfile(patchfp): for line in util.iterfile(patchfp):
line = util.fromnativeeol(line) line = util.fromnativeeol(line)
if not line.startswith(b'#'): if not line.startswith(b'#'):
ncpatchfp.write(line) ncpatchfp.write(line)
patchfp.close() patchfp.close()
ncpatchfp.seek(0) ncpatchfp.seek(0)
newpatches = parsepatch(ncpatchfp) newpatches = parsepatch(ncpatchfp)
if endspaces: if endspaces:
yield (endspaces, b'diff.trailingwhitespace') yield (endspaces, b'diff.trailingwhitespace')
yield (endofline, b'') yield (endofline, b'')
nextisnewline = True nextisnewline = True
def difflabel(func, *args, **kw): def difflabel(func, *args, **kw):
'''yields 2-tuples of (output, label) based on the output of func()''' '''yields 2-tuples of (output, label) based on the output of func()'''
if kw.get(r'opts') and kw[r'opts'].worddiff: if kw.get('opts') and kw['opts'].worddiff:
dodiffhunk = diffsinglehunkinline dodiffhunk = diffsinglehunkinline
else: else:
dodiffhunk = diffsinglehunk dodiffhunk = diffsinglehunk
headprefixes = [ headprefixes = [
(b'diff', b'diff.diffline'), (b'diff', b'diff.diffline'),
(b'copy', b'diff.extended'), (b'copy', b'diff.extended'),
(b'rename', b'diff.extended'), (b'rename', b'diff.extended'),
(b'old', b'diff.extended'), (b'old', b'diff.extended'),

mercurial/policy.py

# py - only load pure Python modules # py - only load pure Python modules
# #
# By default, fall back to the pure modules so the in-place build can # By default, fall back to the pure modules so the in-place build can
# run without recompiling the C extensions. This will be overridden by # run without recompiling the C extensions. This will be overridden by
# __modulepolicy__ generated by setup.py. # __modulepolicy__ generated by setup.py.
policy = b'allow' policy = b'allow'
_packageprefs = { _packageprefs = {
# policy: (versioned package, pure package) # policy: (versioned package, pure package)
b'c': (r'cext', None), b'c': ('cext', None),
b'allow': (r'cext', r'pure'), b'allow': ('cext', 'pure'),
b'cffi': (r'cffi', None), b'cffi': ('cffi', None),
b'cffi-allow': (r'cffi', r'pure'), b'cffi-allow': ('cffi', 'pure'),
b'py': (None, r'pure'), b'py': (None, 'pure'),
# For now, rust policies impact importrust only # For now, rust policies impact importrust only
b'rust+c': (r'cext', None), b'rust+c': ('cext', None),
b'rust+c-allow': (r'cext', r'pure'), b'rust+c-allow': ('cext', 'pure'),
} }
try: try:
from . import __modulepolicy__ from . import __modulepolicy__
policy = __modulepolicy__.modulepolicy policy = __modulepolicy__.modulepolicy
except ImportError: except ImportError:
pass pass
# PyPy doesn't load C extensions. # PyPy doesn't load C extensions.
# #
# The canonical way to do this is to test platform.python_implementation(). # The canonical way to do this is to test platform.python_implementation().
# But we don't import platform and don't bloat for it here. # But we don't import platform and don't bloat for it here.
if r'__pypy__' in sys.builtin_module_names: if '__pypy__' in sys.builtin_module_names:
policy = b'cffi' policy = b'cffi'
# Environment variable can always force settings. # Environment variable can always force settings.
if sys.version_info[0] >= 3: if sys.version_info[0] >= 3:
if r'HGMODULEPOLICY' in os.environ: if 'HGMODULEPOLICY' in os.environ:
policy = os.environ[r'HGMODULEPOLICY'].encode(r'utf-8') policy = os.environ['HGMODULEPOLICY'].encode('utf-8')
else: else:
policy = os.environ.get(r'HGMODULEPOLICY', policy) policy = os.environ.get('HGMODULEPOLICY', policy)
def _importfrom(pkgname, modname): def _importfrom(pkgname, modname):
# from .<pkgname> import <modname> (where . is looked through this module) # from .<pkgname> import <modname> (where . is looked through this module)
fakelocals = {} fakelocals = {}
pkg = __import__(pkgname, globals(), fakelocals, [modname], level=1) pkg = __import__(pkgname, globals(), fakelocals, [modname], level=1)
try: try:
fakelocals[modname] = mod = getattr(pkg, modname) fakelocals[modname] = mod = getattr(pkg, modname)
except AttributeError: except AttributeError:
raise ImportError(r'cannot import name %s' % modname) raise ImportError('cannot import name %s' % modname)
# force import; fakelocals[modname] may be replaced with the real module # force import; fakelocals[modname] may be replaced with the real module
getattr(mod, '__doc__', None) getattr(mod, '__doc__', None)
return fakelocals[modname] return fakelocals[modname]
# keep in sync with "version" in C modules # keep in sync with "version" in C modules
_cextversions = { _cextversions = {
(r'cext', r'base85'): 1, ('cext', 'base85'): 1,
(r'cext', r'bdiff'): 3, ('cext', 'bdiff'): 3,
(r'cext', r'mpatch'): 1, ('cext', 'mpatch'): 1,
(r'cext', r'osutil'): 4, ('cext', 'osutil'): 4,
(r'cext', r'parsers'): 13, ('cext', 'parsers'): 13,
} }
# map import request to other package or module # map import request to other package or module
_modredirects = { _modredirects = {
(r'cext', r'charencode'): (r'cext', r'parsers'), ('cext', 'charencode'): ('cext', 'parsers'),
(r'cffi', r'base85'): (r'pure', r'base85'), ('cffi', 'base85'): ('pure', 'base85'),
(r'cffi', r'charencode'): (r'pure', r'charencode'), ('cffi', 'charencode'): ('pure', 'charencode'),
(r'cffi', r'parsers'): (r'pure', r'parsers'), ('cffi', 'parsers'): ('pure', 'parsers'),
} }
def _checkmod(pkgname, modname, mod): def _checkmod(pkgname, modname, mod):
expected = _cextversions.get((pkgname, modname)) expected = _cextversions.get((pkgname, modname))
actual = getattr(mod, 'version', None) actual = getattr(mod, 'version', None)
if actual != expected: if actual != expected:
raise ImportError( raise ImportError(
r'cannot import module %s.%s ' 'cannot import module %s.%s '
r'(expected version: %d, actual: %r)' '(expected version: %d, actual: %r)'
% (pkgname, modname, expected, actual) % (pkgname, modname, expected, actual)
) )
def importmod(modname): def importmod(modname):
"""Import module according to policy and check API version""" """Import module according to policy and check API version"""
try: try:
verpkg, purepkg = _packageprefs[policy] verpkg, purepkg = _packageprefs[policy]
except KeyError: except KeyError:
raise ImportError(r'invalid HGMODULEPOLICY %r' % policy) raise ImportError('invalid HGMODULEPOLICY %r' % policy)
assert verpkg or purepkg assert verpkg or purepkg
if verpkg: if verpkg:
pn, mn = _modredirects.get((verpkg, modname), (verpkg, modname)) pn, mn = _modredirects.get((verpkg, modname), (verpkg, modname))
try: try:
mod = _importfrom(pn, mn) mod = _importfrom(pn, mn)
if pn == verpkg: if pn == verpkg:
_checkmod(pn, mn, mod) _checkmod(pn, mn, mod)
return mod return mod
If either the module or its member is not available, this returns `default` If either the module or its member is not available, this returns `default`
if policy is permissive and raises `ImportError` if not. if policy is permissive and raises `ImportError` if not.
""" """
if not policy.startswith(b'rust'): if not policy.startswith(b'rust'):
return default return default
try: try:
mod = _importfrom(r'rustext', modname) mod = _importfrom('rustext', modname)
except ImportError: except ImportError:
if _isrustpermissive(): if _isrustpermissive():
return default return default
raise raise
if member is None: if member is None:
return mod return mod
try: try:
return getattr(mod, member) return getattr(mod, member)
except AttributeError: except AttributeError:
if _isrustpermissive(): if _isrustpermissive():
return default return default
raise ImportError("Cannot import name %s" % member) raise ImportError("Cannot import name %s" % member)

mercurial/posix.py

) )
from . import ( from . import (
encoding, encoding,
error, error,
policy, policy,
pycompat, pycompat,
) )
osutil = policy.importmod(r'osutil') osutil = policy.importmod('osutil')
normpath = os.path.normpath normpath = os.path.normpath
samestat = os.path.samestat samestat = os.path.samestat
try: try:
oslink = os.link oslink = os.link
except AttributeError: except AttributeError:
# Some platforms build Python without os.link on systems that are # Some platforms build Python without os.link on systems that are
# vaguely unix-like but don't have hardlink support. For those # vaguely unix-like but don't have hardlink support. For those
removedirs = os.removedirs removedirs = os.removedirs
expandglobs = False expandglobs = False
umask = os.umask(0) umask = os.umask(0)
os.umask(umask) os.umask(umask)
if not pycompat.ispy3: if not pycompat.ispy3:
def posixfile(name, mode=r'r', buffering=-1): def posixfile(name, mode='r', buffering=-1):
fp = open(name, mode=mode, buffering=buffering) fp = open(name, mode=mode, buffering=buffering)
# The position when opening in append mode is implementation defined, so # The position when opening in append mode is implementation defined, so
# make it consistent by always seeking to the end. # make it consistent by always seeking to the end.
if r'a' in mode: if 'a' in mode:
fp.seek(0, os.SEEK_END) fp.seek(0, os.SEEK_END)
return fp return fp
else: else:
# The underlying file object seeks as required in Python 3: # The underlying file object seeks as required in Python 3:
# https://github.com/python/cpython/blob/v3.7.3/Modules/_io/fileio.c#L474 # https://github.com/python/cpython/blob/v3.7.3/Modules/_io/fileio.c#L474
posixfile = open posixfile = open
except ValueError: except ValueError:
c = b'%%%02X' % ord(path[pos : pos + 1]) c = b'%%%02X' % ord(path[pos : pos + 1])
pos += 1 pos += 1
s += c s += c
u = s.decode('utf-8') u = s.decode('utf-8')
# Decompose then lowercase (HFS+ technote specifies lower) # Decompose then lowercase (HFS+ technote specifies lower)
enc = unicodedata.normalize(r'NFD', u).lower().encode('utf-8') enc = unicodedata.normalize('NFD', u).lower().encode('utf-8')
# drop HFS+ ignored characters # drop HFS+ ignored characters
return encoding.hfsignoreclean(enc) return encoding.hfsignoreclean(enc)
if pycompat.sysplatform == b'cygwin': if pycompat.sysplatform == b'cygwin':
# workaround for cygwin, in which mount point part of path is # workaround for cygwin, in which mount point part of path is
# treated as case sensitive, even though underlying NTFS is case # treated as case sensitive, even though underlying NTFS is case
# insensitive. # insensitive.

mercurial/profiling.py

if profformat == b'chrome': if profformat == b'chrome':
showmin = ui.configwith(fraction, b'profiling', b'showmin', 0.005) showmin = ui.configwith(fraction, b'profiling', b'showmin', 0.005)
showmax = ui.configwith(fraction, b'profiling', b'showmax') showmax = ui.configwith(fraction, b'profiling', b'showmax')
kwargs.update(minthreshold=showmin, maxthreshold=showmax) kwargs.update(minthreshold=showmin, maxthreshold=showmax)
elif profformat == b'hotpath': elif profformat == b'hotpath':
# inconsistent config: profiling.showmin # inconsistent config: profiling.showmin
limit = ui.configwith(fraction, b'profiling', b'showmin', 0.05) limit = ui.configwith(fraction, b'profiling', b'showmin', 0.05)
kwargs[r'limit'] = limit kwargs['limit'] = limit
showtime = ui.configbool(b'profiling', b'showtime') showtime = ui.configbool(b'profiling', b'showtime')
kwargs[r'showtime'] = showtime kwargs['showtime'] = showtime
statprof.display(fp, data=data, format=displayformat, **kwargs) statprof.display(fp, data=data, format=displayformat, **kwargs)
class profile(object): class profile(object):
"""Start profiling. """Start profiling.
Profiling is active when the context manager is active. When the context Profiling is active when the context manager is active. When the context

mercurial/pure/charencode.py

Escapes all non-ASCII characters no matter if paranoid is False. Escapes all non-ASCII characters no matter if paranoid is False.
""" """
if paranoid: if paranoid:
jm = _paranoidjsonmap jm = _paranoidjsonmap
else: else:
jm = _jsonmap jm = _jsonmap
# non-BMP char is represented as UTF-16 surrogate pair # non-BMP char is represented as UTF-16 surrogate pair
u16b = u8chars.decode('utf-8', _utf8strict).encode('utf-16', _utf8strict) u16b = u8chars.decode('utf-8', _utf8strict).encode('utf-16', _utf8strict)
u16codes = array.array(r'H', u16b) u16codes = array.array('H', u16b)
u16codes.pop(0) # drop BOM u16codes.pop(0) # drop BOM
return b''.join(jm[x] if x < 128 else b'\\u%04x' % x for x in u16codes) return b''.join(jm[x] if x < 128 else b'\\u%04x' % x for x in u16codes)

mercurial/pure/osutil.py

_DWORD, _DWORD,
_HANDLE, _HANDLE,
] ]
_kernel32.CreateFileA.restype = _HANDLE _kernel32.CreateFileA.restype = _HANDLE
def _raiseioerror(name): def _raiseioerror(name):
err = ctypes.WinError() err = ctypes.WinError()
raise IOError( raise IOError(
err.errno, r'%s: %s' % (encoding.strfromlocal(name), err.strerror) err.errno, '%s: %s' % (encoding.strfromlocal(name), err.strerror)
) )
class posixfile(object): class posixfile(object):
'''a file object aiming for POSIX-like semantics '''a file object aiming for POSIX-like semantics
CPython's open() returns a file that was opened *without* setting the CPython's open() returns a file that was opened *without* setting the
_FILE_SHARE_DELETE flag, which causes rename and unlink to abort. _FILE_SHARE_DELETE flag, which causes rename and unlink to abort.
This even happens if any hardlinked copy of the file is in open state. This even happens if any hardlinked copy of the file is in open state.
if fd == -1: if fd == -1:
_kernel32.CloseHandle(fh) _kernel32.CloseHandle(fh)
_raiseioerror(name) _raiseioerror(name)
f = os.fdopen(fd, pycompat.sysstr(mode), bufsize) f = os.fdopen(fd, pycompat.sysstr(mode), bufsize)
# unfortunately, f.name is '<fdopen>' at this point -- so we store # unfortunately, f.name is '<fdopen>' at this point -- so we store
# the name on this wrapper. We cannot just assign to f.name, # the name on this wrapper. We cannot just assign to f.name,
# because that attribute is read-only. # because that attribute is read-only.
object.__setattr__(self, r'name', name) object.__setattr__(self, 'name', name)
object.__setattr__(self, r'_file', f) object.__setattr__(self, '_file', f)
def __iter__(self): def __iter__(self):
return self._file return self._file
def __getattr__(self, name): def __getattr__(self, name):
return getattr(self._file, name) return getattr(self._file, name)
def __setattr__(self, name, value): def __setattr__(self, name, value):

mercurial/pycompat.py

import inspect import inspect
import json import json
import os import os
import shlex import shlex
import sys import sys
import tempfile import tempfile
ispy3 = sys.version_info[0] >= 3 ispy3 = sys.version_info[0] >= 3
ispypy = r'__pypy__' in sys.builtin_module_names ispypy = '__pypy__' in sys.builtin_module_names
if not ispy3: if not ispy3:
import cookielib import cookielib
import cPickle as pickle import cPickle as pickle
import httplib import httplib
import Queue as queue import Queue as queue
import SocketServer as socketserver import SocketServer as socketserver
import xmlrpclib import xmlrpclib
# #
# https://hg.python.org/cpython/file/v3.5.1/Programs/python.c#l55 # https://hg.python.org/cpython/file/v3.5.1/Programs/python.c#l55
# #
# TODO: On Windows, the native argv is wchar_t, so we'll need a different # TODO: On Windows, the native argv is wchar_t, so we'll need a different
# workaround to simulate the Python 2 (i.e. ANSI Win32 API) behavior. # workaround to simulate the Python 2 (i.e. ANSI Win32 API) behavior.
if getattr(sys, 'argv', None) is not None: if getattr(sys, 'argv', None) is not None:
sysargv = list(map(os.fsencode, sys.argv)) sysargv = list(map(os.fsencode, sys.argv))
bytechr = struct.Struct(r'>B').pack bytechr = struct.Struct('>B').pack
byterepr = b'%r'.__mod__ byterepr = b'%r'.__mod__
class bytestr(bytes): class bytestr(bytes):
"""A bytes which mostly acts as a Python 2 str """A bytes which mostly acts as a Python 2 str
>>> bytestr(), bytestr(bytearray(b'foo')), bytestr(u'ascii'), bytestr(1) >>> bytestr(), bytestr(bytearray(b'foo')), bytestr(u'ascii'), bytestr(1)
('', 'foo', 'ascii', '1') ('', 'foo', 'ascii', '1')
>>> s = bytestr(b'foo') >>> s = bytestr(b'foo')
return tempfile.mkstemp(suffix, prefix, dir) return tempfile.mkstemp(suffix, prefix, dir)
# mode must include 'b'ytes as encoding= is not supported # mode must include 'b'ytes as encoding= is not supported
def namedtempfile( def namedtempfile(
mode=b'w+b', bufsize=-1, suffix=b'', prefix=b'tmp', dir=None, delete=True mode=b'w+b', bufsize=-1, suffix=b'', prefix=b'tmp', dir=None, delete=True
): ):
mode = sysstr(mode) mode = sysstr(mode)
assert r'b' in mode assert 'b' in mode
return tempfile.NamedTemporaryFile( return tempfile.NamedTemporaryFile(
mode, bufsize, suffix=suffix, prefix=prefix, dir=dir, delete=delete mode, bufsize, suffix=suffix, prefix=prefix, dir=dir, delete=delete
) )

mercurial/repoview.py

repoview.method() --> repo.__class__.method(repoview) repoview.method() --> repo.__class__.method(repoview)
The inheritance has to be done dynamically because `repo` can be of any The inheritance has to be done dynamically because `repo` can be of any
subclasses of `localrepo`. Eg: `bundlerepo` or `statichttprepo`. subclasses of `localrepo`. Eg: `bundlerepo` or `statichttprepo`.
""" """
def __init__(self, repo, filtername, visibilityexceptions=None): def __init__(self, repo, filtername, visibilityexceptions=None):
object.__setattr__(self, r'_unfilteredrepo', repo) object.__setattr__(self, '_unfilteredrepo', repo)
object.__setattr__(self, r'filtername', filtername) object.__setattr__(self, 'filtername', filtername)
object.__setattr__(self, r'_clcachekey', None) object.__setattr__(self, '_clcachekey', None)
object.__setattr__(self, r'_clcache', None) object.__setattr__(self, '_clcache', None)
# revs which are exceptions and must not be hidden # revs which are exceptions and must not be hidden
object.__setattr__(self, r'_visibilityexceptions', visibilityexceptions) object.__setattr__(self, '_visibilityexceptions', visibilityexceptions)
# not a propertycache on purpose we shall implement a proper cache later # not a propertycache on purpose we shall implement a proper cache later
@property @property
def changelog(self): def changelog(self):
"""return a filtered version of the changeset """return a filtered version of the changeset
this changelog must not be used for writing""" this changelog must not be used for writing"""
# some cache may be implemented later # some cache may be implemented later
if cl is not None and ( if cl is not None and (
cl.index is not unfiindex or newkey != self._clcachekey cl.index is not unfiindex or newkey != self._clcachekey
): ):
cl = None cl = None
# could have been made None by the previous if # could have been made None by the previous if
if cl is None: if cl is None:
cl = copy.copy(unfichangelog) cl = copy.copy(unfichangelog)
cl.filteredrevs = revs cl.filteredrevs = revs
object.__setattr__(self, r'_clcache', cl) object.__setattr__(self, '_clcache', cl)
object.__setattr__(self, r'_clcachekey', newkey) object.__setattr__(self, '_clcachekey', newkey)
return cl return cl
def unfiltered(self): def unfiltered(self):
"""Return an unfiltered version of a repo""" """Return an unfiltered version of a repo"""
return self._unfilteredrepo return self._unfilteredrepo
def filtered(self, name, visibilityexceptions=None): def filtered(self, name, visibilityexceptions=None):
"""Return a filtered version of a repository""" """Return a filtered version of a repository"""
if name == self.filtername and not visibilityexceptions: if name == self.filtername and not visibilityexceptions:
return self return self
return self.unfiltered().filtered(name, visibilityexceptions) return self.unfiltered().filtered(name, visibilityexceptions)
def __repr__(self): def __repr__(self):
return r'<%s:%s %r>' % ( return '<%s:%s %r>' % (
self.__class__.__name__, self.__class__.__name__,
pycompat.sysstr(self.filtername), pycompat.sysstr(self.filtername),
self.unfiltered(), self.unfiltered(),
) )
# everything access are forwarded to the proxied repo # everything access are forwarded to the proxied repo
def __getattr__(self, attr): def __getattr__(self, attr):
return getattr(self._unfilteredrepo, attr) return getattr(self._unfilteredrepo, attr)

mercurial/revlog.py

REVIDX_ISCENSORED REVIDX_ISCENSORED
REVIDX_ELLIPSIS REVIDX_ELLIPSIS
REVIDX_SIDEDATA REVIDX_SIDEDATA
REVIDX_EXTSTORED REVIDX_EXTSTORED
REVIDX_DEFAULT_FLAGS REVIDX_DEFAULT_FLAGS
REVIDX_FLAGS_ORDER REVIDX_FLAGS_ORDER
REVIDX_RAWTEXT_CHANGING_FLAGS REVIDX_RAWTEXT_CHANGING_FLAGS
parsers = policy.importmod(r'parsers') parsers = policy.importmod('parsers')
rustancestor = policy.importrust(r'ancestor') rustancestor = policy.importrust('ancestor')
rustdagop = policy.importrust(r'dagop') rustdagop = policy.importrust('dagop')
# Aliased for performance. # Aliased for performance.
_zlibdecompress = zlib.decompress _zlibdecompress = zlib.decompress
# max size of revlog with inline data # max size of revlog with inline data
_maxinline = 131072 _maxinline = 131072
_chunksize = 1048576 _chunksize = 1048576
@util.propertycache @util.propertycache
def _compressor(self): def _compressor(self):
engine = util.compengines[self._compengine] engine = util.compengines[self._compengine]
return engine.revlogcompressor(self._compengineopts) return engine.revlogcompressor(self._compengineopts)
def _indexfp(self, mode=b'r'): def _indexfp(self, mode=b'r'):
"""file object for the revlog's index file""" """file object for the revlog's index file"""
args = {r'mode': mode} args = {'mode': mode}
if mode != b'r': if mode != b'r':
args[r'checkambig'] = self._checkambig args['checkambig'] = self._checkambig
if mode == b'w': if mode == b'w':
args[r'atomictemp'] = True args['atomictemp'] = True
return self.opener(self.indexfile, **args) return self.opener(self.indexfile, **args)
def _datafp(self, mode=b'r'): def _datafp(self, mode=b'r'):
"""file object for the revlog's data file""" """file object for the revlog's data file"""
return self.opener(self.datafile, mode=mode) return self.opener(self.datafile, mode=mode)
@contextlib.contextmanager @contextlib.contextmanager
def _datareadfp(self, existingfp=None): def _datareadfp(self, existingfp=None):

mercurial/revlogutils/sidedata.py

# key to store copies related information # key to store copies related information
SD_P1COPIES = 8 SD_P1COPIES = 8
SD_P2COPIES = 9 SD_P2COPIES = 9
SD_FILESADDED = 10 SD_FILESADDED = 10
SD_FILESREMOVED = 11 SD_FILESREMOVED = 11
# internal format constant # internal format constant
SIDEDATA_HEADER = struct.Struct(r'>H') SIDEDATA_HEADER = struct.Struct('>H')
SIDEDATA_ENTRY = struct.Struct(r'>HL20s') SIDEDATA_ENTRY = struct.Struct('>HL20s')
def sidedatawriteprocessor(rl, text, sidedata): def sidedatawriteprocessor(rl, text, sidedata):
sidedata = list(sidedata.items()) sidedata = list(sidedata.items())
sidedata.sort() sidedata.sort()
rawtext = [SIDEDATA_HEADER.pack(len(sidedata))] rawtext = [SIDEDATA_HEADER.pack(len(sidedata))]
for key, value in sidedata: for key, value in sidedata:
digest = hashlib.sha1(value).digest() digest = hashlib.sha1(value).digest()

mercurial/scmposix.py

try: try:
try: try:
fd = dev.fileno() fd = dev.fileno()
except AttributeError: except AttributeError:
continue continue
if not os.isatty(fd): if not os.isatty(fd):
continue continue
arri = fcntl.ioctl(fd, TIOCGWINSZ, b'\0' * 8) arri = fcntl.ioctl(fd, TIOCGWINSZ, b'\0' * 8)
height, width = array.array(r'h', arri)[:2] height, width = array.array('h', arri)[:2]
if width > 0 and height > 0: if width > 0 and height > 0:
return width, height return width, height
except ValueError: except ValueError:
pass pass
except IOError as e: except IOError as e:
if e[0] == errno.EINVAL: if e[0] == errno.EINVAL:
pass pass
else: else:
raise raise
return 80, 24 return 80, 24

mercurial/scmutil.py

stringutil, stringutil,
) )
if pycompat.iswindows: if pycompat.iswindows:
from . import scmwindows as scmplatform from . import scmwindows as scmplatform
else: else:
from . import scmposix as scmplatform from . import scmposix as scmplatform
parsers = policy.importmod(r'parsers') parsers = policy.importmod('parsers')
termsize = scmplatform.termsize termsize = scmplatform.termsize
class status(tuple): class status(tuple):
'''Named tuple with a list of files per status. The 'deleted', 'unknown' '''Named tuple with a list of files per status. The 'deleted', 'unknown'
and 'ignored' properties are only relevant to the working copy. and 'ignored' properties are only relevant to the working copy.
''' '''

mercurial/setdiscovery.py

sample.update(random.sample(takefrom, more)) sample.update(random.sample(takefrom, more))
else: else:
takefrom.sort() takefrom.sort()
sample.update(takefrom[:more]) sample.update(takefrom[:more])
return sample return sample
partialdiscovery = policy.importrust( partialdiscovery = policy.importrust(
r'discovery', member=r'PartialDiscovery', default=partialdiscovery 'discovery', member='PartialDiscovery', default=partialdiscovery
) )
def findcommonheads( def findcommonheads(
ui, ui,
local, local,
remote, remote,
initialsamplesize=100, initialsamplesize=100,

mercurial/smartset.py

def _asclist(self): def _asclist(self):
asclist = self._list[:] asclist = self._list[:]
asclist.sort() asclist.sort()
return asclist return asclist
@util.propertycache @util.propertycache
def _list(self): def _list(self):
# _list is only lazily constructed if we have _set # _list is only lazily constructed if we have _set
assert r'_set' in self.__dict__ assert '_set' in self.__dict__
return list(self._set) return list(self._set)
def __iter__(self): def __iter__(self):
if self._ascending is None: if self._ascending is None:
return iter(self._list) return iter(self._list)
elif self._ascending: elif self._ascending:
return iter(self._asclist) return iter(self._asclist)
else: else:
def reverse(self): def reverse(self):
if self._ascending is None: if self._ascending is None:
self._list.reverse() self._list.reverse()
else: else:
self._ascending = not self._ascending self._ascending = not self._ascending
self._istopo = False self._istopo = False
def __len__(self): def __len__(self):
if r'_list' in self.__dict__: if '_list' in self.__dict__:
return len(self._list) return len(self._list)
else: else:
return len(self._set) return len(self._set)
def isascending(self): def isascending(self):
"""Returns True if the collection is ascending order, False if not. """Returns True if the collection is ascending order, False if not.
This is part of the mandatory API for smartset.""" This is part of the mandatory API for smartset."""
else: else:
return self._asclist[0] return self._asclist[0]
return None return None
def _fastsetop(self, other, op): def _fastsetop(self, other, op):
# try to use native set operations as fast paths # try to use native set operations as fast paths
if ( if (
type(other) is baseset type(other) is baseset
and r'_set' in other.__dict__ and '_set' in other.__dict__
and r'_set' in self.__dict__ and '_set' in self.__dict__
and self._ascending is not None and self._ascending is not None
): ):
s = baseset( s = baseset(
data=getattr(self._set, op)(other._set), istopo=self._istopo data=getattr(self._set, op)(other._set), istopo=self._istopo
) )
s._ascending = self._ascending s._ascending = self._ascending
else: else:
s = getattr(super(baseset, self), op)(other) s = getattr(super(baseset, self), op)(other)

mercurial/sslutil.py

self._ciphers = ciphers self._ciphers = ciphers
def wrap_socket(self, socket, server_hostname=None, server_side=False): def wrap_socket(self, socket, server_hostname=None, server_side=False):
# server_hostname is unique to SSLContext.wrap_socket and is used # server_hostname is unique to SSLContext.wrap_socket and is used
# for SNI in that context. So there's nothing for us to do with it # for SNI in that context. So there's nothing for us to do with it
# in this legacy code since we don't support SNI. # in this legacy code since we don't support SNI.
args = { args = {
r'keyfile': self._keyfile, 'keyfile': self._keyfile,
r'certfile': self._certfile, 'certfile': self._certfile,
r'server_side': server_side, 'server_side': server_side,
r'cert_reqs': self.verify_mode, 'cert_reqs': self.verify_mode,
r'ssl_version': self.protocol, 'ssl_version': self.protocol,
r'ca_certs': self._cacerts, 'ca_certs': self._cacerts,
r'ciphers': self._ciphers, 'ciphers': self._ciphers,
} }
return ssl.wrap_socket(socket, **args) return ssl.wrap_socket(socket, **args)
def _hostsettings(ui, hostname): def _hostsettings(ui, hostname):
"""Obtain security settings for a hostname. """Obtain security settings for a hostname.
# Try to print more helpful error messages for known failures. # Try to print more helpful error messages for known failures.
if util.safehasattr(e, b'reason'): if util.safehasattr(e, b'reason'):
# This error occurs when the client and server don't share a # This error occurs when the client and server don't share a
# common/supported SSL/TLS protocol. We've disabled SSLv2 and SSLv3 # common/supported SSL/TLS protocol. We've disabled SSLv2 and SSLv3
# outright. Hopefully the reason for this error is that we require # outright. Hopefully the reason for this error is that we require
# TLS 1.1+ and the server only supports TLS 1.0. Whatever the # TLS 1.1+ and the server only supports TLS 1.0. Whatever the
# reason, try to emit an actionable warning. # reason, try to emit an actionable warning.
if e.reason == r'UNSUPPORTED_PROTOCOL': if e.reason == 'UNSUPPORTED_PROTOCOL':
# We attempted TLS 1.0+. # We attempted TLS 1.0+.
if settings[b'protocolui'] == b'tls1.0': if settings[b'protocolui'] == b'tls1.0':
# We support more than just TLS 1.0+. If this happens, # We support more than just TLS 1.0+. If this happens,
# the likely scenario is either the client or the server # the likely scenario is either the client or the server
# is really old. (e.g. server doesn't support TLS 1.0+ or # is really old. (e.g. server doesn't support TLS 1.0+ or
# client doesn't support modern TLS versions introduced # client doesn't support modern TLS versions introduced
# several years from when this comment was written). # several years from when this comment was written).
if supportedprotocols != {b'tls1.0'}: if supportedprotocols != {b'tls1.0'}:
) )
ui.warn( ui.warn(
_( _(
b'(see https://mercurial-scm.org/wiki/SecureConnections ' b'(see https://mercurial-scm.org/wiki/SecureConnections '
b'for more info)\n' b'for more info)\n'
) )
) )
elif ( elif e.reason == 'CERTIFICATE_VERIFY_FAILED' and pycompat.iswindows:
e.reason == r'CERTIFICATE_VERIFY_FAILED' and pycompat.iswindows
):
ui.warn( ui.warn(
_( _(
b'(the full certificate chain may not be available ' b'(the full certificate chain may not be available '
b'locally; see "hg help debugssl")\n' b'locally; see "hg help debugssl")\n'
) )
) )
raise raise
CRLs is not handled. CRLs is not handled.
Returns error message if any problems are found and None on success. Returns error message if any problems are found and None on success.
''' '''
if not cert: if not cert:
return _(b'no certificate received') return _(b'no certificate received')
dnsnames = [] dnsnames = []
san = cert.get(r'subjectAltName', []) san = cert.get('subjectAltName', [])
for key, value in san: for key, value in san:
if key == r'DNS': if key == 'DNS':
try: try:
if _dnsnamematch(value, hostname): if _dnsnamematch(value, hostname):
return return
except wildcarderror as e: except wildcarderror as e:
return stringutil.forcebytestr(e.args[0]) return stringutil.forcebytestr(e.args[0])
dnsnames.append(value) dnsnames.append(value)
if not dnsnames: if not dnsnames:
# The subject is only checked when there is no DNS in subjectAltName. # The subject is only checked when there is no DNS in subjectAltName.
for sub in cert.get(r'subject', []): for sub in cert.get('subject', []):
for key, value in sub: for key, value in sub:
# According to RFC 2818 the most specific Common Name must # According to RFC 2818 the most specific Common Name must
# be used. # be used.
if key == r'commonName': if key == 'commonName':
# 'subject' entries are unicode. # 'subject' entries are unicode.
try: try:
value = value.encode('ascii') value = value.encode('ascii')
except UnicodeEncodeError: except UnicodeEncodeError:
return _(b'IDN in certificate not supported') return _(b'IDN in certificate not supported')
try: try:
if _dnsnamematch(value, hostname): if _dnsnamematch(value, hostname):

mercurial/statichttprepo.py

self.pos = pos self.pos = pos
def read(self, bytes=None): def read(self, bytes=None):
req = urlreq.request(pycompat.strurl(self.url)) req = urlreq.request(pycompat.strurl(self.url))
end = b'' end = b''
if bytes: if bytes:
end = self.pos + bytes - 1 end = self.pos + bytes - 1
if self.pos or end: if self.pos or end:
req.add_header(r'Range', r'bytes=%d-%s' % (self.pos, end)) req.add_header('Range', 'bytes=%d-%s' % (self.pos, end))
try: try:
f = self.opener.open(req) f = self.opener.open(req)
data = f.read() data = f.read()
code = f.code code = f.code
except urlerr.httperror as inst: except urlerr.httperror as inst:
num = inst.code == 404 and errno.ENOENT or None num = inst.code == 404 and errno.ENOENT or None
raise IOError(num, inst) raise IOError(num, inst)

mercurial/statprof.py

state = ProfileState() state = ProfileState()
class CodeSite(object): class CodeSite(object):
cache = {} cache = {}
__slots__ = (r'path', r'lineno', r'function', r'source') __slots__ = ('path', 'lineno', 'function', 'source')
def __init__(self, path, lineno, function): def __init__(self, path, lineno, function):
assert isinstance(path, bytes) assert isinstance(path, bytes)
self.path = path self.path = path
self.lineno = lineno self.lineno = lineno
assert isinstance(function, bytes) assert isinstance(function, bytes)
self.function = function self.function = function
self.source = None self.source = None
if len(source) > length: if len(source) > length:
source = source[: (length - 3)] + b"..." source = source[: (length - 3)] + b"..."
return source return source
def filename(self): def filename(self):
return os.path.basename(self.path) return os.path.basename(self.path)
def skipname(self): def skipname(self):
return r'%s:%s' % (self.filename(), self.function) return '%s:%s' % (self.filename(), self.function)
class Sample(object): class Sample(object):
__slots__ = (r'stack', r'time') __slots__ = ('stack', 'time')
def __init__(self, stack, time): def __init__(self, stack, time):
self.stack = stack self.stack = stack
self.time = time self.time = time
@classmethod @classmethod
def from_frame(cls, frame, time): def from_frame(cls, frame, time):
stack = [] stack = []
if i < len(stack): if i < len(stack):
child.add(stack[i:], time) child.add(stack[i:], time)
root = HotNode(None) root = HotNode(None)
lasttime = data.samples[0].time lasttime = data.samples[0].time
for sample in data.samples: for sample in data.samples:
root.add(sample.stack[::-1], sample.time - lasttime) root.add(sample.stack[::-1], sample.time - lasttime)
lasttime = sample.time lasttime = sample.time
showtime = kwargs.get(r'showtime', True) showtime = kwargs.get('showtime', True)
def _write(node, depth, multiple_siblings): def _write(node, depth, multiple_siblings):
site = node.site site = node.site
visiblechildren = [ visiblechildren = [
c c
for c in pycompat.itervalues(node.children) for c in pycompat.itervalues(node.children)
if c.count >= (limit * root.count) if c.count >= (limit * root.count)
] ]
def stackid(stack): def stackid(stack):
if not stack: if not stack:
return return
if stack in stack2id: if stack in stack2id:
return stack2id[stack] return stack2id[stack]
parent = stackid(stack[1:]) parent = stackid(stack[1:])
myid = len(stack2id) myid = len(stack2id)
stack2id[stack] = myid stack2id[stack] = myid
id2stack.append(dict(category=stack[0][0], name=r'%s %s' % stack[0])) id2stack.append(dict(category=stack[0][0], name='%s %s' % stack[0]))
if parent is not None: if parent is not None:
id2stack[-1].update(parent=parent) id2stack[-1].update(parent=parent)
return myid return myid
# The sampling profiler can sample multiple times without # The sampling profiler can sample multiple times without
# advancing the clock, potentially causing the Chrome trace viewer # advancing the clock, potentially causing the Chrome trace viewer
# to render single-pixel columns that we cannot zoom in on. We # to render single-pixel columns that we cannot zoom in on. We
# work around this by pretending that zero-duration samples are a # work around this by pretending that zero-duration samples are a
oldcat, oldfunc = laststack.popleft() oldcat, oldfunc = laststack.popleft()
oldtime, oldidx = lastseen.popleft() oldtime, oldidx = lastseen.popleft()
duration = sample.time - oldtime duration = sample.time - oldtime
if minthreshold <= duration <= maxthreshold: if minthreshold <= duration <= maxthreshold:
# ensure no zero-duration events # ensure no zero-duration events
sampletime = max(oldtime + clamp, sample.time) sampletime = max(oldtime + clamp, sample.time)
samples.append( samples.append(
dict( dict(
ph=r'E', ph='E',
name=oldfunc, name=oldfunc,
cat=oldcat, cat=oldcat,
sf=oldsid, sf=oldsid,
ts=sampletime * 1e6, ts=sampletime * 1e6,
pid=0, pid=0,
) )
) )
else: else:
blacklist.add(oldidx) blacklist.add(oldidx)
# Much fiddling to synthesize correctly(ish) nested begin/end # Much fiddling to synthesize correctly(ish) nested begin/end
# events given only stack snapshots. # events given only stack snapshots.
for sample in data.samples: for sample in data.samples:
stack = tuple( stack = tuple(
( (
( (
r'%s:%d' '%s:%d'
% (simplifypath(pycompat.sysstr(frame.path)), frame.lineno), % (simplifypath(pycompat.sysstr(frame.path)), frame.lineno),
pycompat.sysstr(frame.function), pycompat.sysstr(frame.function),
) )
for frame in sample.stack for frame in sample.stack
) )
) )
qstack = collections.deque(stack) qstack = collections.deque(stack)
if laststack == qstack: if laststack == qstack:
continue continue
while laststack and qstack and laststack[-1] == qstack[-1]: while laststack and qstack and laststack[-1] == qstack[-1]:
laststack.pop() laststack.pop()
qstack.pop() qstack.pop()
while laststack: while laststack:
poplast() poplast()
for f in reversed(qstack): for f in reversed(qstack):
lastseen.appendleft((sample.time, len(samples))) lastseen.appendleft((sample.time, len(samples)))
laststack.appendleft(f) laststack.appendleft(f)
path, name = f path, name = f
sid = stackid(tuple(laststack)) sid = stackid(tuple(laststack))
samples.append( samples.append(
dict( dict(
ph=r'B', ph='B',
name=name, name=name,
cat=path, cat=path,
ts=sample.time * 1e6, ts=sample.time * 1e6,
sf=sid, sf=sid,
pid=0, pid=0,
) )
) )
laststack = collections.deque(stack) laststack = collections.deque(stack)
if len(argv) == 1: if len(argv) == 1:
printusage() printusage()
return 0 return 0
displayargs = {} displayargs = {}
optstart = 2 optstart = 2
displayargs[b'function'] = None displayargs[b'function'] = None
if argv[1] == r'hotpath': if argv[1] == 'hotpath':
displayargs[b'format'] = DisplayFormats.Hotpath displayargs[b'format'] = DisplayFormats.Hotpath
elif argv[1] == r'lines': elif argv[1] == 'lines':
displayargs[b'format'] = DisplayFormats.ByLine displayargs[b'format'] = DisplayFormats.ByLine
elif argv[1] == r'functions': elif argv[1] == 'functions':
displayargs[b'format'] = DisplayFormats.ByMethod displayargs[b'format'] = DisplayFormats.ByMethod
elif argv[1] == r'function': elif argv[1] == 'function':
displayargs[b'format'] = DisplayFormats.AboutMethod displayargs[b'format'] = DisplayFormats.AboutMethod
displayargs[b'function'] = argv[2] displayargs[b'function'] = argv[2]
optstart = 3 optstart = 3
elif argv[1] == r'flame': elif argv[1] == 'flame':
displayargs[b'format'] = DisplayFormats.FlameGraph displayargs[b'format'] = DisplayFormats.FlameGraph
else: else:
printusage() printusage()
return 0 return 0
# process options # process options
try: try:
opts, args = pycompat.getoptb( opts, args = pycompat.getoptb(
displayargs[b'scriptpath'] = value displayargs[b'scriptpath'] = value
elif o in ("-h", "help"): elif o in ("-h", "help"):
printusage() printusage()
return 0 return 0
else: else:
assert False, b"unhandled option %s" % o assert False, b"unhandled option %s" % o
if not path: if not path:
print(r'must specify --file to load') print('must specify --file to load')
return 1 return 1
load_data(path=path) load_data(path=path)
display(**pycompat.strkwargs(displayargs)) display(**pycompat.strkwargs(displayargs))
return 0 return 0
if __name__ == "__main__": if __name__ == "__main__":
sys.exit(main()) sys.exit(main())

mercurial/store.py

manifest, manifest,
node, node,
policy, policy,
pycompat, pycompat,
util, util,
vfs as vfsmod, vfs as vfsmod,
) )
parsers = policy.importmod(r'parsers') parsers = policy.importmod('parsers')
# how much bytes should be read from fncache in one read # how much bytes should be read from fncache in one read
# It is done to prevent loading large fncache files into memory # It is done to prevent loading large fncache files into memory
fncache_chunksize = 10 ** 6 fncache_chunksize = 10 ** 6
def _matchtrackedpath(path, matcher): def _matchtrackedpath(path, matcher):
"""parses a fncache entry and returns whether the entry is tracking a path """parses a fncache entry and returns whether the entry is tracking a path
matched by matcher or not. matched by matcher or not.

mercurial/subrepo.py

'''get a unique filename for the store hash cache of a remote repository''' '''get a unique filename for the store hash cache of a remote repository'''
return node.hex(hashlib.sha1(_expandedabspath(remotepath)).digest())[0:12] return node.hex(hashlib.sha1(_expandedabspath(remotepath)).digest())[0:12]
class SubrepoAbort(error.Abort): class SubrepoAbort(error.Abort):
"""Exception class used to avoid handling a subrepo error more than once""" """Exception class used to avoid handling a subrepo error more than once"""
def __init__(self, *args, **kw): def __init__(self, *args, **kw):
self.subrepo = kw.pop(r'subrepo', None) self.subrepo = kw.pop('subrepo', None)
self.cause = kw.pop(r'cause', None) self.cause = kw.pop('cause', None)
error.Abort.__init__(self, *args, **kw) error.Abort.__init__(self, *args, **kw)
def annotatesubrepoerror(func): def annotatesubrepoerror(func):
def decoratedmethod(self, *args, **kargs): def decoratedmethod(self, *args, **kargs):
try: try:
res = func(self, *args, **kargs) res = func(self, *args, **kargs)
except SubrepoAbort as ex: except SubrepoAbort as ex:
@annotatesubrepoerror @annotatesubrepoerror
def revert(self, substate, *pats, **opts): def revert(self, substate, *pats, **opts):
# reverting a subrepo is a 2 step process: # reverting a subrepo is a 2 step process:
# 1. if the no_backup is not set, revert all modified # 1. if the no_backup is not set, revert all modified
# files inside the subrepo # files inside the subrepo
# 2. update the subrepo to the revision specified in # 2. update the subrepo to the revision specified in
# the corresponding substate dictionary # the corresponding substate dictionary
self.ui.status(_(b'reverting subrepo %s\n') % substate[0]) self.ui.status(_(b'reverting subrepo %s\n') % substate[0])
if not opts.get(r'no_backup'): if not opts.get('no_backup'):
# Revert all files on the subrepo, creating backups # Revert all files on the subrepo, creating backups
# Note that this will not recursively revert subrepos # Note that this will not recursively revert subrepos
# We could do it if there was a set:subrepos() predicate # We could do it if there was a set:subrepos() predicate
opts = opts.copy() opts = opts.copy()
opts[r'date'] = None opts['date'] = None
opts[r'rev'] = substate[1] opts['rev'] = substate[1]
self.filerevert(*pats, **opts) self.filerevert(*pats, **opts)
# Update the repo to the revision specified in the given substate # Update the repo to the revision specified in the given substate
if not opts.get(r'dry_run'): if not opts.get('dry_run'):
self.get(substate, overwrite=True) self.get(substate, overwrite=True)
def filerevert(self, *pats, **opts): def filerevert(self, *pats, **opts):
ctx = self._repo[opts[r'rev']] ctx = self._repo[opts['rev']]
parents = self._repo.dirstate.parents() parents = self._repo.dirstate.parents()
if opts.get(r'all'): if opts.get('all'):
pats = [b'set:modified()'] pats = [b'set:modified()']
else: else:
pats = [] pats = []
cmdutil.revert(self.ui, self._repo, ctx, parents, *pats, **opts) cmdutil.revert(self.ui, self._repo, ctx, parents, *pats, **opts)
def shortid(self, revid): def shortid(self, revid):
return revid[:12] return revid[:12]
) )
def _svncommand(self, commands, filename=b'', failok=False): def _svncommand(self, commands, filename=b'', failok=False):
cmd = [self._exe] cmd = [self._exe]
extrakw = {} extrakw = {}
if not self.ui.interactive(): if not self.ui.interactive():
# Making stdin be a pipe should prevent svn from behaving # Making stdin be a pipe should prevent svn from behaving
# interactively even if we can't pass --non-interactive. # interactively even if we can't pass --non-interactive.
extrakw[r'stdin'] = subprocess.PIPE extrakw['stdin'] = subprocess.PIPE
# Starting in svn 1.5 --non-interactive is a global flag # Starting in svn 1.5 --non-interactive is a global flag
# instead of being per-command, but we need to support 1.4 so # instead of being per-command, but we need to support 1.4 so
# we have to be intelligent about what commands take # we have to be intelligent about what commands take
# --non-interactive. # --non-interactive.
if commands[0] in (b'update', b'checkout', b'commit'): if commands[0] in (b'update', b'checkout', b'commit'):
cmd.append(b'--non-interactive') cmd.append(b'--non-interactive')
cmd.extend(commands) cmd.extend(commands)
if filename is not None: if filename is not None:
return not self.wvfs.exists(b'.svn') return not self.wvfs.exists(b'.svn')
def _wcrevs(self): def _wcrevs(self):
# Get the working directory revision as well as the last # Get the working directory revision as well as the last
# commit revision so we can compare the subrepo state with # commit revision so we can compare the subrepo state with
# both. We used to store the working directory one. # both. We used to store the working directory one.
output, err = self._svncommand([b'info', b'--xml']) output, err = self._svncommand([b'info', b'--xml'])
doc = xml.dom.minidom.parseString(output) doc = xml.dom.minidom.parseString(output)
entries = doc.getElementsByTagName(r'entry') entries = doc.getElementsByTagName('entry')
lastrev, rev = b'0', b'0' lastrev, rev = b'0', b'0'
if entries: if entries:
rev = pycompat.bytestr(entries[0].getAttribute(r'revision')) or b'0' rev = pycompat.bytestr(entries[0].getAttribute('revision')) or b'0'
commits = entries[0].getElementsByTagName(r'commit') commits = entries[0].getElementsByTagName('commit')
if commits: if commits:
lastrev = ( lastrev = (
pycompat.bytestr(commits[0].getAttribute(r'revision')) pycompat.bytestr(commits[0].getAttribute('revision'))
or b'0' or b'0'
) )
return (lastrev, rev) return (lastrev, rev)
def _wcrev(self): def _wcrev(self):
return self._wcrevs()[0] return self._wcrevs()[0]
def _wcchanged(self): def _wcchanged(self):
"""Return (changes, extchanges, missing) where changes is True """Return (changes, extchanges, missing) where changes is True
if the working directory was changed, extchanges is if the working directory was changed, extchanges is
True if any of these changes concern an external entry and missing True if any of these changes concern an external entry and missing
is True if any change is a missing entry. is True if any change is a missing entry.
""" """
output, err = self._svncommand([b'status', b'--xml']) output, err = self._svncommand([b'status', b'--xml'])
externals, changes, missing = [], [], [] externals, changes, missing = [], [], []
doc = xml.dom.minidom.parseString(output) doc = xml.dom.minidom.parseString(output)
for e in doc.getElementsByTagName(r'entry'): for e in doc.getElementsByTagName('entry'):
s = e.getElementsByTagName(r'wc-status') s = e.getElementsByTagName('wc-status')
if not s: if not s:
continue continue
item = s[0].getAttribute(r'item') item = s[0].getAttribute('item')
props = s[0].getAttribute(r'props') props = s[0].getAttribute('props')
path = e.getAttribute(r'path').encode('utf8') path = e.getAttribute('path').encode('utf8')
if item == r'external': if item == 'external':
externals.append(path) externals.append(path)
elif item == r'missing': elif item == 'missing':
missing.append(path) missing.append(path)
if item not in ( if item not in (
r'', '',
r'normal', 'normal',
r'unversioned', 'unversioned',
r'external', 'external',
) or props not in (r'', r'none', r'normal'): ) or props not in ('', 'none', 'normal'):
changes.append(path) changes.append(path)
for path in changes: for path in changes:
for ext in externals: for ext in externals:
if path == ext or path.startswith(ext + pycompat.ossep): if path == ext or path.startswith(ext + pycompat.ossep):
return True, True, bool(missing) return True, True, bool(missing)
return bool(changes), False, bool(missing) return bool(changes), False, bool(missing)
@annotatesubrepoerror @annotatesubrepoerror
# push is a no-op for SVN # push is a no-op for SVN
return True return True
@annotatesubrepoerror @annotatesubrepoerror
def files(self): def files(self):
output = self._svncommand([b'list', b'--recursive', b'--xml'])[0] output = self._svncommand([b'list', b'--recursive', b'--xml'])[0]
doc = xml.dom.minidom.parseString(output) doc = xml.dom.minidom.parseString(output)
paths = [] paths = []
for e in doc.getElementsByTagName(r'entry'): for e in doc.getElementsByTagName('entry'):
kind = pycompat.bytestr(e.getAttribute(r'kind')) kind = pycompat.bytestr(e.getAttribute('kind'))
if kind != b'file': if kind != b'file':
continue continue
name = r''.join( name = ''.join(
c.data c.data
for c in e.getElementsByTagName(r'name')[0].childNodes for c in e.getElementsByTagName('name')[0].childNodes
if c.nodeType == c.TEXT_NODE if c.nodeType == c.TEXT_NODE
) )
paths.append(name.encode('utf8')) paths.append(name.encode('utf8'))
return paths return paths
def filedata(self, name, decode): def filedata(self, name, decode):
return self._svncommand([b'cat'], name)[0] return self._svncommand([b'cat'], name)[0]
command.append(b"-f") # should be added, even if ignored command.append(b"-f") # should be added, even if ignored
if ui.verbose or not exact: if ui.verbose or not exact:
ui.status(_(b'adding %s\n') % uipathfn(f)) ui.status(_(b'adding %s\n') % uipathfn(f))
if f in tracked: # hg prints 'adding' even if already tracked if f in tracked: # hg prints 'adding' even if already tracked
if exact: if exact:
rejected.append(f) rejected.append(f)
continue continue
if not opts.get(r'dry_run'): if not opts.get('dry_run'):
self._gitcommand(command + [f]) self._gitcommand(command + [f])
for f in rejected: for f in rejected:
ui.warn(_(b"%s already tracked!\n") % uipathfn(f)) ui.warn(_(b"%s already tracked!\n") % uipathfn(f))
return rejected return rejected
@annotatesubrepoerror @annotatesubrepoerror
if not revision: if not revision:
return total return total
self._fetch(source, revision) self._fetch(source, revision)
# Parse git's native archive command. # Parse git's native archive command.
# This should be much faster than manually traversing the trees # This should be much faster than manually traversing the trees
# and objects with many subprocess calls. # and objects with many subprocess calls.
tarstream = self._gitcommand([b'archive', revision], stream=True) tarstream = self._gitcommand([b'archive', revision], stream=True)
tar = tarfile.open(fileobj=tarstream, mode=r'r|') tar = tarfile.open(fileobj=tarstream, mode='r|')
relpath = subrelpath(self) relpath = subrelpath(self)
progress = self.ui.makeprogress( progress = self.ui.makeprogress(
_(b'archiving (%s)') % relpath, unit=_(b'files') _(b'archiving (%s)') % relpath, unit=_(b'files')
) )
progress.update(0) progress.update(0)
for info in tar: for info in tar:
if info.isdir(): if info.isdir():
continue continue
elif status == b'A': elif status == b'A':
added.append(f) added.append(f)
elif status == b'D': elif status == b'D':
removed.append(f) removed.append(f)
deleted, unknown, ignored, clean = [], [], [], [] deleted, unknown, ignored, clean = [], [], [], []
command = [b'status', b'--porcelain', b'-z'] command = [b'status', b'--porcelain', b'-z']
if opts.get(r'unknown'): if opts.get('unknown'):
command += [b'--untracked-files=all'] command += [b'--untracked-files=all']
if opts.get(r'ignored'): if opts.get('ignored'):
command += [b'--ignored'] command += [b'--ignored']
out = self._gitcommand(command) out = self._gitcommand(command)
changedfiles = set() changedfiles = set()
changedfiles.update(modified) changedfiles.update(modified)
changedfiles.update(added) changedfiles.update(added)
changedfiles.update(removed) changedfiles.update(removed)
for line in out.split(b'\0'): for line in out.split(b'\0'):
if filename2: if filename2:
changedfiles.add(filename2) changedfiles.add(filename2)
if st == b'??': if st == b'??':
unknown.append(filename1) unknown.append(filename1)
elif st == b'!!': elif st == b'!!':
ignored.append(filename1) ignored.append(filename1)
if opts.get(r'clean'): if opts.get('clean'):
out = self._gitcommand([b'ls-files']) out = self._gitcommand([b'ls-files'])
for f in out.split(b'\n'): for f in out.split(b'\n'):
if not f in changedfiles: if not f in changedfiles:
clean.append(f) clean.append(f)
return scmutil.status( return scmutil.status(
modified, added, removed, deleted, unknown, ignored, clean modified, added, removed, deleted, unknown, ignored, clean
) )
@annotatesubrepoerror @annotatesubrepoerror
def diff(self, ui, diffopts, node2, match, prefix, **opts): def diff(self, ui, diffopts, node2, match, prefix, **opts):
node1 = self._state[1] node1 = self._state[1]
cmd = [b'diff', b'--no-renames'] cmd = [b'diff', b'--no-renames']
if opts[r'stat']: if opts['stat']:
cmd.append(b'--stat') cmd.append(b'--stat')
else: else:
# for Git, this also implies '-p' # for Git, this also implies '-p'
cmd.append(b'-U%d' % diffopts.context) cmd.append(b'-U%d' % diffopts.context)
if diffopts.noprefix: if diffopts.noprefix:
cmd.extend( cmd.extend(
[b'--src-prefix=%s/' % prefix, b'--dst-prefix=%s/' % prefix] [b'--src-prefix=%s/' % prefix, b'--dst-prefix=%s/' % prefix]
output += self._gitcommand(cmd + [b'--', f]) + b'\n' output += self._gitcommand(cmd + [b'--', f]) + b'\n'
if output.strip(): if output.strip():
ui.write(output) ui.write(output)
@annotatesubrepoerror @annotatesubrepoerror
def revert(self, substate, *pats, **opts): def revert(self, substate, *pats, **opts):
self.ui.status(_(b'reverting subrepo %s\n') % substate[0]) self.ui.status(_(b'reverting subrepo %s\n') % substate[0])
if not opts.get(r'no_backup'): if not opts.get('no_backup'):
status = self.status(None) status = self.status(None)
names = status.modified names = status.modified
for name in names: for name in names:
# backuppath() expects a path relative to the parent repo (the # backuppath() expects a path relative to the parent repo (the
# repo that ui.origbackuppath is relative to) # repo that ui.origbackuppath is relative to)
parentname = os.path.join(self._path, name) parentname = os.path.join(self._path, name)
bakname = scmutil.backuppath( bakname = scmutil.backuppath(
self.ui, self._subparent, parentname self.ui, self._subparent, parentname
) )
self.ui.note( self.ui.note(
_(b'saving current version of %s as %s\n') _(b'saving current version of %s as %s\n')
% (name, os.path.relpath(bakname)) % (name, os.path.relpath(bakname))
) )
util.rename(self.wvfs.join(name), bakname) util.rename(self.wvfs.join(name), bakname)
if not opts.get(r'dry_run'): if not opts.get('dry_run'):
self.get(substate, overwrite=True) self.get(substate, overwrite=True)
return [] return []
def shortid(self, revid): def shortid(self, revid):
return revid[:7] return revid[:7]
types = { types = {
b'hg': hgsubrepo, b'hg': hgsubrepo,
b'svn': svnsubrepo, b'svn': svnsubrepo,
b'git': gitsubrepo, b'git': gitsubrepo,
} }

mercurial/testing/storage.py

potentially bad data into the store in order to facilitate testing. potentially bad data into the store in order to facilitate testing.
Returns a type that is a ``unittest.TestCase`` that can be used for Returns a type that is a ``unittest.TestCase`` that can be used for
testing the object implementing the file storage interface. Simply testing the object implementing the file storage interface. Simply
assign the returned value to a module-level attribute and a test loader assign the returned value to a module-level attribute and a test loader
should find and run it automatically. should find and run it automatically.
""" """
d = { d = {
r'_makefilefn': makefilefn, '_makefilefn': makefilefn,
r'_maketransactionfn': maketransactionfn, '_maketransactionfn': maketransactionfn,
r'_addrawrevisionfn': addrawrevisionfn, '_addrawrevisionfn': addrawrevisionfn,
} }
return type(r'ifileindextests', (ifileindextests,), d) return type('ifileindextests', (ifileindextests,), d)
def makeifiledatatests(makefilefn, maketransactionfn, addrawrevisionfn): def makeifiledatatests(makefilefn, maketransactionfn, addrawrevisionfn):
d = { d = {
r'_makefilefn': makefilefn, '_makefilefn': makefilefn,
r'_maketransactionfn': maketransactionfn, '_maketransactionfn': maketransactionfn,
r'_addrawrevisionfn': addrawrevisionfn, '_addrawrevisionfn': addrawrevisionfn,
} }
return type(r'ifiledatatests', (ifiledatatests,), d) return type('ifiledatatests', (ifiledatatests,), d)
def makeifilemutationtests(makefilefn, maketransactionfn, addrawrevisionfn): def makeifilemutationtests(makefilefn, maketransactionfn, addrawrevisionfn):
d = { d = {
r'_makefilefn': makefilefn, '_makefilefn': makefilefn,
r'_maketransactionfn': maketransactionfn, '_maketransactionfn': maketransactionfn,
r'_addrawrevisionfn': addrawrevisionfn, '_addrawrevisionfn': addrawrevisionfn,
} }
return type(r'ifilemutationtests', (ifilemutationtests,), d) return type('ifilemutationtests', (ifilemutationtests,), d)

mercurial/transaction.py

vfsmap, vfsmap,
journalname, journalname,
undoname=None, undoname=None,
after=None, after=None,
createmode=None, createmode=None,
validator=None, validator=None,
releasefn=None, releasefn=None,
checkambigfiles=None, checkambigfiles=None,
name=r'<unnamed>', name='<unnamed>',
): ):
"""Begin a new transaction """Begin a new transaction
Begins a new transaction that allows rolling back writes in the event of Begins a new transaction that allows rolling back writes in the event of
an exception. an exception.
* `after`: called after the transaction has been committed * `after`: called after the transaction has been committed
* `createmode`: the mode of the journal file that will be created * `createmode`: the mode of the journal file that will be created
# holds callback to call when writing the transaction # holds callback to call when writing the transaction
self._finalizecallback = {} self._finalizecallback = {}
# hold callback for post transaction close # hold callback for post transaction close
self._postclosecallback = {} self._postclosecallback = {}
# holds callbacks to call during abort # holds callbacks to call during abort
self._abortcallback = {} self._abortcallback = {}
def __repr__(self): def __repr__(self):
name = r'/'.join(self._names) name = '/'.join(self._names)
return r'<transaction name=%s, count=%d, usages=%d>' % ( return '<transaction name=%s, count=%d, usages=%d>' % (
name, name,
self._count, self._count,
self._usages, self._usages,
) )
def __del__(self): def __del__(self):
if self._journal: if self._journal:
self._abort() self._abort()
if file not in self._map: if file not in self._map:
raise KeyError(file) raise KeyError(file)
index = self._map[file] index = self._map[file]
self._entries[index] = (file, offset, data) self._entries[index] = (file, offset, data)
self._file.write(b"%s\0%d\n" % (file, offset)) self._file.write(b"%s\0%d\n" % (file, offset))
self._file.flush() self._file.flush()
@active @active
def nest(self, name=r'<unnamed>'): def nest(self, name='<unnamed>'):
self._count += 1 self._count += 1
self._usages += 1 self._usages += 1
self._names.append(name) self._names.append(name)
return self return self
def release(self): def release(self):
if self._count > 0: if self._count > 0:
self._usages -= 1 self._usages -= 1

mercurial/ui.py

% (f, user, group) % (f, user, group)
) )
return False return False
def readconfig( def readconfig(
self, filename, root=None, trust=False, sections=None, remap=None self, filename, root=None, trust=False, sections=None, remap=None
): ):
try: try:
fp = open(filename, r'rb') fp = open(filename, 'rb')
except IOError: except IOError:
if not sections: # ignore unless we were looking for something if not sections: # ignore unless we were looking for something
return return
raise raise
cfg = config.config() cfg = config.config()
trusted = sections or trust or self._trusted(fp, filename) trusted = sections or trust or self._trusted(fp, filename)
When labeling output for a specific command, a label of When labeling output for a specific command, a label of
"cmdname.type" is recommended. For example, status issues "cmdname.type" is recommended. For example, status issues
a label of "status.modified" for modified files. a label of "status.modified" for modified files.
''' '''
dest = self._fout dest = self._fout
# inlined _write() for speed # inlined _write() for speed
if self._buffers: if self._buffers:
label = opts.get(r'label', b'') label = opts.get('label', b'')
if label and self._bufferapplylabels: if label and self._bufferapplylabels:
self._buffers[-1].extend(self.label(a, label) for a in args) self._buffers[-1].extend(self.label(a, label) for a in args)
else: else:
self._buffers[-1].extend(args) self._buffers[-1].extend(args)
return return
# inlined _writenobuf() for speed # inlined _writenobuf() for speed
if not opts.get(r'keepprogressbar', False): if not opts.get('keepprogressbar', False):
self._progclear() self._progclear()
msg = b''.join(args) msg = b''.join(args)
# opencode timeblockedsection because this is a critical path # opencode timeblockedsection because this is a critical path
starttime = util.timer() starttime = util.timer()
try: try:
if self._colormode == b'win32': if self._colormode == b'win32':
# windows color printing is its own can of crab, defer to # windows color printing is its own can of crab, defer to
# the color module and that is it. # the color module and that is it.
color.win32print(self, dest.write, msg, **opts) color.win32print(self, dest.write, msg, **opts)
else: else:
if self._colormode is not None: if self._colormode is not None:
label = opts.get(r'label', b'') label = opts.get('label', b'')
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[b'stdio_blocked'] += ( self._blockedtimes[b'stdio_blocked'] += (
util.timer() - starttime util.timer() - starttime
) * 1000 ) * 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', b'') label = opts.get('label', b'')
if label and self._bufferapplylabels: if label and self._bufferapplylabels:
self._buffers[-1].extend(self.label(a, label) for a in args) self._buffers[-1].extend(self.label(a, label) for a in args)
else: else:
self._buffers[-1].extend(args) self._buffers[-1].extend(args)
else: else:
self._writenobuf(dest, *args, **opts) self._writenobuf(dest, *args, **opts)
def _writenobuf(self, dest, *args, **opts): def _writenobuf(self, dest, *args, **opts):
# update write() as well if you touch this code # update write() as well if you touch this code
if not opts.get(r'keepprogressbar', False): if not opts.get('keepprogressbar', False):
self._progclear() self._progclear()
msg = b''.join(args) msg = b''.join(args)
# opencode timeblockedsection because this is a critical path # opencode timeblockedsection because this is a critical path
starttime = util.timer() starttime = util.timer()
try: try:
if dest is self._ferr and not getattr(self._fout, 'closed', False): if dest is self._ferr and not getattr(self._fout, 'closed', False):
self._fout.flush() self._fout.flush()
if getattr(dest, 'structured', False): if getattr(dest, 'structured', False):
# channel for machine-readable output with metadata, where # channel for machine-readable output with metadata, where
# no extra colorization is necessary. # no extra colorization is necessary.
dest.write(msg, **opts) dest.write(msg, **opts)
elif self._colormode == b'win32': elif self._colormode == b'win32':
# windows color printing is its own can of crab, defer to # windows color printing is its own can of crab, defer to
# the color module and that is it. # the color module and that is it.
color.win32print(self, dest.write, msg, **opts) color.win32print(self, dest.write, msg, **opts)
else: else:
if self._colormode is not None: if self._colormode is not None:
label = opts.get(r'label', b'') label = opts.get('label', b'')
msg = self.label(msg, label) msg = self.label(msg, label)
dest.write(msg) dest.write(msg)
# stderr may be buffered under win32 when redirected to files, # stderr may be buffered under win32 when redirected to files,
# including stdout. # including stdout.
if dest is self._ferr and not getattr(self._ferr, 'closed', False): if dest is self._ferr and not getattr(self._ferr, 'closed', False):
dest.flush() dest.flush()
except IOError as err: except IOError as err:
if dest is self._ferr and err.errno in ( if dest is self._ferr and err.errno in (
def prompt(self, msg, default=b"y"): def prompt(self, msg, default=b"y"):
"""Prompt user with msg, read response. """Prompt user with msg, read response.
If ui is not interactive, the default is returned. If ui is not interactive, the default is returned.
""" """
return self._prompt(msg, default=default) return self._prompt(msg, default=default)
def _prompt(self, msg, **opts): def _prompt(self, msg, **opts):
default = opts[r'default'] default = opts['default']
if not self.interactive(): if not self.interactive():
self._writemsg(self._fmsgout, msg, b' ', type=b'prompt', **opts) self._writemsg(self._fmsgout, msg, b' ', type=b'prompt', **opts)
self._writemsg( self._writemsg(
self._fmsgout, default or b'', b"\n", type=b'promptecho' self._fmsgout, default or b'', b"\n", type=b'promptecho'
) )
return default return default
try: try:
r = self._readline(prompt=msg, promptopts=opts) r = self._readline(prompt=msg, promptopts=opts)
# to interact with tty even if fin is not a tty. # to interact with tty even if fin is not a tty.
with self.timeblockedsection(b'stdio'): with self.timeblockedsection(b'stdio'):
if self.configbool(b'ui', b'nontty'): if self.configbool(b'ui', b'nontty'):
l = self._fin.readline() l = self._fin.readline()
if not l: if not l:
raise EOFError raise EOFError
return l.rstrip(b'\n') return l.rstrip(b'\n')
else: else:
return getpass.getpass(r'') return getpass.getpass('')
except EOFError: except EOFError:
raise error.ResponseExpected() raise error.ResponseExpected()
def status(self, *msg, **opts): def status(self, *msg, **opts):
'''write status message to output (if ui.quiet is False) '''write status message to output (if ui.quiet is False)
This adds an output label of "ui.status". This adds an output label of "ui.status".
''' '''
rdir = None rdir = None
if self.configbool(b'experimental', b'editortmpinhg'): if self.configbool(b'experimental', b'editortmpinhg'):
rdir = repopath rdir = repopath
(fd, name) = pycompat.mkstemp( (fd, name) = pycompat.mkstemp(
prefix=b'hg-' + extra[b'prefix'] + b'-', suffix=suffix, dir=rdir prefix=b'hg-' + extra[b'prefix'] + b'-', suffix=suffix, dir=rdir
) )
try: try:
f = os.fdopen(fd, r'wb') f = os.fdopen(fd, 'wb')
f.write(util.tonativeeol(text)) f.write(util.tonativeeol(text))
f.close() f.close()
environ = {b'HGUSER': user} environ = {b'HGUSER': user}
if b'transplant_source' in extra: if b'transplant_source' in extra:
environ.update( environ.update(
{b'HGREVISION': hex(extra[b'transplant_source'])} {b'HGREVISION': hex(extra[b'transplant_source'])}
) )
self.system( self.system(
b"%s \"%s\"" % (editor, name), b"%s \"%s\"" % (editor, name),
environ=environ, environ=environ,
onerr=error.Abort, onerr=error.Abort,
errprefix=_(b"edit failed"), errprefix=_(b"edit failed"),
blockedtag=b'editor', blockedtag=b'editor',
) )
f = open(name, r'rb') f = open(name, 'rb')
t = util.fromnativeeol(f.read()) t = util.fromnativeeol(f.read())
f.close() f.close()
finally: finally:
os.unlink(name) os.unlink(name)
return t return t
def system( def system(
self.write_err( self.write_err(
b'Traceback (most recent call last):\n', b'Traceback (most recent call last):\n',
b''.join(exctb[:-1]), b''.join(exctb[:-1]),
b''.join(causetb), b''.join(causetb),
b''.join(exconly), b''.join(exconly),
) )
else: else:
output = traceback.format_exception(exc[0], exc[1], exc[2]) output = traceback.format_exception(exc[0], exc[1], exc[2])
self.write_err(encoding.strtolocal(r''.join(output))) self.write_err(encoding.strtolocal(''.join(output)))
return self.tracebackflag or force return self.tracebackflag or force
def geteditor(self): def geteditor(self):
'''return editor to use''' '''return editor to use'''
if pycompat.sysplatform == b'plan9': if pycompat.sysplatform == b'plan9':
# vi is the MIPS instruction simulator on Plan 9. We # vi is the MIPS instruction simulator on Plan 9. We
# instead default to E to plumb commit messages to # instead default to E to plumb commit messages to
# avoid confusion. # avoid confusion.
def _writemsgwith(write, dest, *args, **opts): def _writemsgwith(write, dest, *args, **opts):
"""Write ui message with the given ui._write*() function """Write ui message with the given ui._write*() function
The specified message type is translated to 'ui.<type>' label if the dest The specified message type is translated to 'ui.<type>' label if the dest
isn't a structured channel, so that the message will be colorized. isn't a structured channel, so that the message will be colorized.
""" """
# TODO: maybe change 'type' to a mandatory option # TODO: maybe change 'type' to a mandatory option
if r'type' in opts and not getattr(dest, 'structured', False): if 'type' in opts and not getattr(dest, 'structured', False):
opts[r'label'] = opts.get(r'label', b'') + b' ui.%s' % opts.pop(r'type') opts['label'] = opts.get('label', b'') + b' ui.%s' % opts.pop('type')
write(dest, *args, **opts) write(dest, *args, **opts)

mercurial/url.py

if ui.configbool(b"http_proxy", b"always"): if ui.configbool(b"http_proxy", b"always"):
self.no_list = [] self.no_list = []
else: else:
self.no_list = no_list self.no_list = no_list
# Keys and values need to be str because the standard library # Keys and values need to be str because the standard library
# expects them to be. # expects them to be.
proxyurl = str(proxy) proxyurl = str(proxy)
proxies = {r'http': proxyurl, r'https': proxyurl} proxies = {'http': proxyurl, 'https': proxyurl}
ui.debug(b'proxying through %s\n' % util.hidepassword(bytes(proxy))) ui.debug(b'proxying through %s\n' % util.hidepassword(bytes(proxy)))
else: else:
proxies = {} proxies = {}
urlreq.proxyhandler.__init__(self, proxies) urlreq.proxyhandler.__init__(self, proxies)
self.ui = ui self.ui = ui
def proxy_open(self, req, proxy, type_): def proxy_open(self, req, proxy, type_):
return keepalive.HTTPConnection.getresponse(self) return keepalive.HTTPConnection.getresponse(self)
# Large parts of this function have their origin from before Python 2.6 # Large parts of this function have their origin from before Python 2.6
# and could potentially be removed. # and could potentially be removed.
def _generic_start_transaction(handler, h, req): def _generic_start_transaction(handler, h, req):
tunnel_host = req._tunnel_host tunnel_host = req._tunnel_host
if tunnel_host: if tunnel_host:
if tunnel_host[:7] not in [r'http://', r'https:/']: if tunnel_host[:7] not in ['http://', 'https:/']:
tunnel_host = r'https://' + tunnel_host tunnel_host = 'https://' + tunnel_host
new_tunnel = True new_tunnel = True
else: else:
tunnel_host = urllibcompat.getselector(req) tunnel_host = urllibcompat.getselector(req)
new_tunnel = False new_tunnel = False
if new_tunnel or tunnel_host == urllibcompat.getfullurl(req): # has proxy if new_tunnel or tunnel_host == urllibcompat.getfullurl(req): # has proxy
u = util.url(pycompat.bytesurl(tunnel_host)) u = util.url(pycompat.bytesurl(tunnel_host))
if new_tunnel or u.scheme == b'https': # only use CONNECT for HTTPS if new_tunnel or u.scheme == b'https': # only use CONNECT for HTTPS
h.realhostport = b':'.join([u.host, (u.port or b'443')]) h.realhostport = b':'.join([u.host, (u.port or b'443')])
h.headers = req.headers.copy() h.headers = req.headers.copy()
h.headers.update(handler.parent.addheaders) h.headers.update(handler.parent.addheaders)
return return
h.realhostport = None h.realhostport = None
h.headers = None h.headers = None
def _generic_proxytunnel(self): def _generic_proxytunnel(self):
proxyheaders = dict( proxyheaders = dict(
[ [
(x, self.headers[x]) (x, self.headers[x])
for x in self.headers for x in self.headers
if x.lower().startswith(r'proxy-') if x.lower().startswith('proxy-')
] ]
) )
self.send(b'CONNECT %s HTTP/1.0\r\n' % self.realhostport) self.send(b'CONNECT %s HTTP/1.0\r\n' % self.realhostport)
for header in pycompat.iteritems(proxyheaders): for header in pycompat.iteritems(proxyheaders):
self.send(b'%s: %s\r\n' % header) self.send(b'%s: %s\r\n' % header)
self.send(b'\r\n') self.send(b'\r\n')
# majority of the following code is duplicated from # majority of the following code is duplicated from
) )
def retry_http_basic_auth(self, host, req, realm): def retry_http_basic_auth(self, host, req, realm):
user, pw = self.passwd.find_user_password( user, pw = self.passwd.find_user_password(
realm, urllibcompat.getfullurl(req) realm, urllibcompat.getfullurl(req)
) )
if pw is not None: if pw is not None:
raw = b"%s:%s" % (pycompat.bytesurl(user), pycompat.bytesurl(pw)) raw = b"%s:%s" % (pycompat.bytesurl(user), pycompat.bytesurl(pw))
auth = r'Basic %s' % pycompat.strurl(base64.b64encode(raw).strip()) auth = 'Basic %s' % pycompat.strurl(base64.b64encode(raw).strip())
if req.get_header(self.auth_header, None) == auth: if req.get_header(self.auth_header, None) == auth:
return None return None
self.auth = auth self.auth = auth
req.add_unredirected_header(self.auth_header, auth) req.add_unredirected_header(self.auth_header, auth)
return self.parent.open(req) return self.parent.open(req)
else: else:
return None return None
# own distribution name. Since servers should not be using the user # own distribution name. Since servers should not be using the user
# agent string for anything, clients should be able to define whatever # agent string for anything, clients should be able to define whatever
# user agent they deem appropriate. # user agent they deem appropriate.
# #
# The custom user agent is for lfs, because unfortunately some servers # The custom user agent is for lfs, because unfortunately some servers
# do look at this value. # do look at this value.
if not useragent: if not useragent:
agent = b'mercurial/proto-1.0 (Mercurial %s)' % util.version() agent = b'mercurial/proto-1.0 (Mercurial %s)' % util.version()
opener.addheaders = [(r'User-agent', pycompat.sysstr(agent))] opener.addheaders = [('User-agent', pycompat.sysstr(agent))]
else: else:
opener.addheaders = [(r'User-agent', pycompat.sysstr(useragent))] opener.addheaders = [('User-agent', pycompat.sysstr(useragent))]
# This header should only be needed by wire protocol requests. But it has # This header should only be needed by wire protocol requests. But it has
# been sent on all requests since forever. We keep sending it for backwards # been sent on all requests since forever. We keep sending it for backwards
# compatibility reasons. Modern versions of the wire protocol use # compatibility reasons. Modern versions of the wire protocol use
# X-HgProto-<N> for advertising client support. # X-HgProto-<N> for advertising client support.
if sendaccept: if sendaccept:
opener.addheaders.append((r'Accept', r'application/mercurial-0.1')) opener.addheaders.append(('Accept', 'application/mercurial-0.1'))
return opener return opener
def open(ui, url_, data=None, sendaccept=True): def open(ui, url_, data=None, sendaccept=True):
u = util.url(url_) u = util.url(url_)
if u.scheme: if u.scheme:
u.scheme = u.scheme.lower() u.scheme = u.scheme.lower()

mercurial/urllibcompat.py

class _pycompatstub(object): class _pycompatstub(object):
def __init__(self): def __init__(self):
self._aliases = {} self._aliases = {}
def _registeraliases(self, origin, items): def _registeraliases(self, origin, items):
"""Add items that will be populated at the first access""" """Add items that will be populated at the first access"""
items = map(_sysstr, items) items = map(_sysstr, items)
self._aliases.update( self._aliases.update(
(item.replace(r'_', r'').lower(), (origin, item)) for item in items (item.replace('_', '').lower(), (origin, item)) for item in items
) )
def _registeralias(self, origin, attr, name): def _registeralias(self, origin, attr, name):
"""Alias ``origin``.``attr`` as ``name``""" """Alias ``origin``.``attr`` as ``name``"""
self._aliases[_sysstr(name)] = (origin, _sysstr(attr)) self._aliases[_sysstr(name)] = (origin, _sysstr(attr))
def __getattr__(self, name): def __getattr__(self, name):
try: try:
b"SimpleHTTPRequestHandler", b"SimpleHTTPRequestHandler",
b"CGIHTTPRequestHandler", b"CGIHTTPRequestHandler",
), ),
) )
# urllib.parse.quote() accepts both str and bytes, decodes bytes # urllib.parse.quote() accepts both str and bytes, decodes bytes
# (if necessary), and returns str. This is wonky. We provide a custom # (if necessary), and returns str. This is wonky. We provide a custom
# implementation that only accepts bytes and emits bytes. # implementation that only accepts bytes and emits bytes.
def quote(s, safe=r'/'): def quote(s, safe='/'):
# bytestr has an __iter__ that emits characters. quote_from_bytes() # bytestr has an __iter__ that emits characters. quote_from_bytes()
# does an iteration and expects ints. We coerce to bytes to appease it. # does an iteration and expects ints. We coerce to bytes to appease it.
if isinstance(s, pycompat.bytestr): if isinstance(s, pycompat.bytestr):
s = bytes(s) s = bytes(s)
s = urllib.parse.quote_from_bytes(s, safe=safe) s = urllib.parse.quote_from_bytes(s, safe=safe)
return s.encode('ascii', 'strict') return s.encode('ascii', 'strict')
# urllib.parse.urlencode() returns str. We use this function to make # urllib.parse.urlencode() returns str. We use this function to make

mercurial/util.py

urllibcompat, urllibcompat,
) )
from .utils import ( from .utils import (
compression, compression,
procutil, procutil,
stringutil, stringutil,
) )
rustdirs = policy.importrust(r'dirstate', r'Dirs') rustdirs = policy.importrust('dirstate', 'Dirs')
base85 = policy.importmod(r'base85') base85 = policy.importmod('base85')
osutil = policy.importmod(r'osutil') osutil = policy.importmod('osutil')
parsers = policy.importmod(r'parsers') parsers = policy.importmod('parsers')
b85decode = base85.b85decode b85decode = base85.b85decode
b85encode = base85.b85encode b85encode = base85.b85encode
cookielib = pycompat.cookielib cookielib = pycompat.cookielib
httplib = pycompat.httplib httplib = pycompat.httplib
pickle = pycompat.pickle pickle = pycompat.pickle
safehasattr = pycompat.safehasattr safehasattr = pycompat.safehasattr
_dowarn = bool(encoding.environ.get(b'HGEMITWARNINGS')) _dowarn = bool(encoding.environ.get(b'HGEMITWARNINGS'))
if _dowarn: if _dowarn:
# explicitly unfilter our warning for python 2.7 # explicitly unfilter our warning for python 2.7
# #
# The option of setting PYTHONWARNINGS in the test runner was investigated. # The option of setting PYTHONWARNINGS in the test runner was investigated.
# However, module name set through PYTHONWARNINGS was exactly matched, so # However, module name set through PYTHONWARNINGS was exactly matched, so
# we cannot set 'mercurial' and have it match eg: 'mercurial.scmutil'. This # we cannot set 'mercurial' and have it match eg: 'mercurial.scmutil'. This
# makes the whole PYTHONWARNINGS thing useless for our usecase. # makes the whole PYTHONWARNINGS thing useless for our usecase.
warnings.filterwarnings(r'default', r'', DeprecationWarning, r'mercurial') warnings.filterwarnings('default', '', DeprecationWarning, 'mercurial')
warnings.filterwarnings(r'default', r'', DeprecationWarning, r'hgext') warnings.filterwarnings('default', '', DeprecationWarning, 'hgext')
warnings.filterwarnings(r'default', r'', DeprecationWarning, r'hgext3rd') warnings.filterwarnings('default', '', DeprecationWarning, 'hgext3rd')
if _dowarn and pycompat.ispy3: if _dowarn and pycompat.ispy3:
# silence warning emitted by passing user string to re.sub() # silence warning emitted by passing user string to re.sub()
warnings.filterwarnings( warnings.filterwarnings(
r'ignore', r'bad escape', DeprecationWarning, r'mercurial' 'ignore', 'bad escape', DeprecationWarning, 'mercurial'
) )
warnings.filterwarnings( warnings.filterwarnings(
r'ignore', r'invalid escape sequence', DeprecationWarning, r'mercurial' 'ignore', 'invalid escape sequence', DeprecationWarning, 'mercurial'
) )
# TODO: reinvent imp.is_frozen() # TODO: reinvent imp.is_frozen()
warnings.filterwarnings( warnings.filterwarnings(
r'ignore', 'ignore',
r'the imp module is deprecated', 'the imp module is deprecated',
DeprecationWarning, DeprecationWarning,
r'mercurial', 'mercurial',
) )
def nouideprecwarn(msg, version, stacklevel=1): def nouideprecwarn(msg, version, stacklevel=1):
"""Issue an python native deprecation warning """Issue an python native deprecation warning
This is a noop outside of tests, use 'ui.deprecwarn' when possible. This is a noop outside of tests, use 'ui.deprecwarn' when possible.
""" """
class fileobjectproxy(object): class fileobjectproxy(object):
"""A proxy around file objects that tells a watcher when events occur. """A proxy around file objects that tells a watcher when events occur.
This type is intended to only be used for testing purposes. Think hard This type is intended to only be used for testing purposes. Think hard
before using it in important code. before using it in important code.
""" """
__slots__ = ( __slots__ = (
r'_orig', '_orig',
r'_observer', '_observer',
) )
def __init__(self, fh, observer): def __init__(self, fh, observer):
object.__setattr__(self, r'_orig', fh) object.__setattr__(self, '_orig', fh)
object.__setattr__(self, r'_observer', observer) object.__setattr__(self, '_observer', observer)
def __getattribute__(self, name): def __getattribute__(self, name):
ours = { ours = {
r'_observer', '_observer',
# IOBase # IOBase
r'close', 'close',
# closed if a property # closed if a property
r'fileno', 'fileno',
r'flush', 'flush',
r'isatty', 'isatty',
r'readable', 'readable',
r'readline', 'readline',
r'readlines', 'readlines',
r'seek', 'seek',
r'seekable', 'seekable',
r'tell', 'tell',
r'truncate', 'truncate',
r'writable', 'writable',
r'writelines', 'writelines',
# RawIOBase # RawIOBase
r'read', 'read',
r'readall', 'readall',
r'readinto', 'readinto',
r'write', 'write',
# BufferedIOBase # BufferedIOBase
# raw is a property # raw is a property
r'detach', 'detach',
# read defined above # read defined above
r'read1', 'read1',
# readinto defined above # readinto defined above
# write defined above # write defined above
} }
# We only observe some methods. # We only observe some methods.
if name in ours: if name in ours:
return object.__getattribute__(self, name) return object.__getattribute__(self, name)
return getattr(object.__getattribute__(self, r'_orig'), name) return getattr(object.__getattribute__(self, '_orig'), name)
def __nonzero__(self): def __nonzero__(self):
return bool(object.__getattribute__(self, r'_orig')) return bool(object.__getattribute__(self, '_orig'))
__bool__ = __nonzero__ __bool__ = __nonzero__
def __delattr__(self, name): def __delattr__(self, name):
return delattr(object.__getattribute__(self, r'_orig'), name) return delattr(object.__getattribute__(self, '_orig'), name)
def __setattr__(self, name, value): def __setattr__(self, name, value):
return setattr(object.__getattribute__(self, r'_orig'), name, value) return setattr(object.__getattribute__(self, '_orig'), name, value)
def __iter__(self): def __iter__(self):
return object.__getattribute__(self, r'_orig').__iter__() return object.__getattribute__(self, '_orig').__iter__()
def _observedcall(self, name, *args, **kwargs): def _observedcall(self, name, *args, **kwargs):
# Call the original object. # Call the original object.
orig = object.__getattribute__(self, r'_orig') orig = object.__getattribute__(self, '_orig')
res = getattr(orig, name)(*args, **kwargs) res = getattr(orig, name)(*args, **kwargs)
# Call a method on the observer of the same name with arguments # Call a method on the observer of the same name with arguments
# so it can react, log, etc. # so it can react, log, etc.
observer = object.__getattribute__(self, r'_observer') observer = object.__getattribute__(self, '_observer')
fn = getattr(observer, name, None) fn = getattr(observer, name, None)
if fn: if fn:
fn(res, *args, **kwargs) fn(res, *args, **kwargs)
return res return res
def close(self, *args, **kwargs): def close(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'close', *args, **kwargs 'close', *args, **kwargs
) )
def fileno(self, *args, **kwargs): def fileno(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'fileno', *args, **kwargs 'fileno', *args, **kwargs
) )
def flush(self, *args, **kwargs): def flush(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'flush', *args, **kwargs 'flush', *args, **kwargs
) )
def isatty(self, *args, **kwargs): def isatty(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'isatty', *args, **kwargs 'isatty', *args, **kwargs
) )
def readable(self, *args, **kwargs): def readable(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'readable', *args, **kwargs 'readable', *args, **kwargs
) )
def readline(self, *args, **kwargs): def readline(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'readline', *args, **kwargs 'readline', *args, **kwargs
) )
def readlines(self, *args, **kwargs): def readlines(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'readlines', *args, **kwargs 'readlines', *args, **kwargs
) )
def seek(self, *args, **kwargs): def seek(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'seek', *args, **kwargs 'seek', *args, **kwargs
) )
def seekable(self, *args, **kwargs): def seekable(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'seekable', *args, **kwargs 'seekable', *args, **kwargs
) )
def tell(self, *args, **kwargs): def tell(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'tell', *args, **kwargs 'tell', *args, **kwargs
) )
def truncate(self, *args, **kwargs): def truncate(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'truncate', *args, **kwargs 'truncate', *args, **kwargs
) )
def writable(self, *args, **kwargs): def writable(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'writable', *args, **kwargs 'writable', *args, **kwargs
) )
def writelines(self, *args, **kwargs): def writelines(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'writelines', *args, **kwargs 'writelines', *args, **kwargs
) )
def read(self, *args, **kwargs): def read(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'read', *args, **kwargs 'read', *args, **kwargs
) )
def readall(self, *args, **kwargs): def readall(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'readall', *args, **kwargs 'readall', *args, **kwargs
) )
def readinto(self, *args, **kwargs): def readinto(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'readinto', *args, **kwargs 'readinto', *args, **kwargs
) )
def write(self, *args, **kwargs): def write(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'write', *args, **kwargs 'write', *args, **kwargs
) )
def detach(self, *args, **kwargs): def detach(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'detach', *args, **kwargs 'detach', *args, **kwargs
) )
def read1(self, *args, **kwargs): def read1(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'read1', *args, **kwargs 'read1', *args, **kwargs
) )
class observedbufferedinputpipe(bufferedinputpipe): class observedbufferedinputpipe(bufferedinputpipe):
"""A variation of bufferedinputpipe that is aware of fileobjectproxy. """A variation of bufferedinputpipe that is aware of fileobjectproxy.
``bufferedinputpipe`` makes low-level calls to ``os.read()`` that ``bufferedinputpipe`` makes low-level calls to ``os.read()`` that
bypass ``fileobjectproxy``. Because of this, we need to make bypass ``fileobjectproxy``. Because of this, we need to make
fn = getattr(self._input._observer, 'bufferedreadline', None) fn = getattr(self._input._observer, 'bufferedreadline', None)
if fn: if fn:
fn(res) fn(res)
return res return res
PROXIED_SOCKET_METHODS = { PROXIED_SOCKET_METHODS = {
r'makefile', 'makefile',
r'recv', 'recv',
r'recvfrom', 'recvfrom',
r'recvfrom_into', 'recvfrom_into',
r'recv_into', 'recv_into',
r'send', 'send',
r'sendall', 'sendall',
r'sendto', 'sendto',
r'setblocking', 'setblocking',
r'settimeout', 'settimeout',
r'gettimeout', 'gettimeout',
r'setsockopt', 'setsockopt',
} }
class socketproxy(object): class socketproxy(object):
"""A proxy around a socket that tells a watcher when events occur. """A proxy around a socket that tells a watcher when events occur.
This is like ``fileobjectproxy`` except for sockets. This is like ``fileobjectproxy`` except for sockets.
This type is intended to only be used for testing purposes. Think hard This type is intended to only be used for testing purposes. Think hard
before using it in important code. before using it in important code.
""" """
__slots__ = ( __slots__ = (
r'_orig', '_orig',
r'_observer', '_observer',
) )
def __init__(self, sock, observer): def __init__(self, sock, observer):
object.__setattr__(self, r'_orig', sock) object.__setattr__(self, '_orig', sock)
object.__setattr__(self, r'_observer', observer) object.__setattr__(self, '_observer', observer)
def __getattribute__(self, name): def __getattribute__(self, name):
if name in PROXIED_SOCKET_METHODS: if name in PROXIED_SOCKET_METHODS:
return object.__getattribute__(self, name) return object.__getattribute__(self, name)
return getattr(object.__getattribute__(self, r'_orig'), name) return getattr(object.__getattribute__(self, '_orig'), name)
def __delattr__(self, name): def __delattr__(self, name):
return delattr(object.__getattribute__(self, r'_orig'), name) return delattr(object.__getattribute__(self, '_orig'), name)
def __setattr__(self, name, value): def __setattr__(self, name, value):
return setattr(object.__getattribute__(self, r'_orig'), name, value) return setattr(object.__getattribute__(self, '_orig'), name, value)
def __nonzero__(self): def __nonzero__(self):
return bool(object.__getattribute__(self, r'_orig')) return bool(object.__getattribute__(self, '_orig'))
__bool__ = __nonzero__ __bool__ = __nonzero__
def _observedcall(self, name, *args, **kwargs): def _observedcall(self, name, *args, **kwargs):
# Call the original object. # Call the original object.
orig = object.__getattribute__(self, r'_orig') orig = object.__getattribute__(self, '_orig')
res = getattr(orig, name)(*args, **kwargs) res = getattr(orig, name)(*args, **kwargs)
# Call a method on the observer of the same name with arguments # Call a method on the observer of the same name with arguments
# so it can react, log, etc. # so it can react, log, etc.
observer = object.__getattribute__(self, r'_observer') observer = object.__getattribute__(self, '_observer')
fn = getattr(observer, name, None) fn = getattr(observer, name, None)
if fn: if fn:
fn(res, *args, **kwargs) fn(res, *args, **kwargs)
return res return res
def makefile(self, *args, **kwargs): def makefile(self, *args, **kwargs):
res = object.__getattribute__(self, r'_observedcall')( res = object.__getattribute__(self, '_observedcall')(
r'makefile', *args, **kwargs 'makefile', *args, **kwargs
) )
# The file object may be used for I/O. So we turn it into a # The file object may be used for I/O. So we turn it into a
# proxy using our observer. # proxy using our observer.
observer = object.__getattribute__(self, r'_observer') observer = object.__getattribute__(self, '_observer')
return makeloggingfileobject( return makeloggingfileobject(
observer.fh, observer.fh,
res, res,
observer.name, observer.name,
reads=observer.reads, reads=observer.reads,
writes=observer.writes, writes=observer.writes,
logdata=observer.logdata, logdata=observer.logdata,
logdataapis=observer.logdataapis, logdataapis=observer.logdataapis,
) )
def recv(self, *args, **kwargs): def recv(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'recv', *args, **kwargs 'recv', *args, **kwargs
) )
def recvfrom(self, *args, **kwargs): def recvfrom(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'recvfrom', *args, **kwargs 'recvfrom', *args, **kwargs
) )
def recvfrom_into(self, *args, **kwargs): def recvfrom_into(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'recvfrom_into', *args, **kwargs 'recvfrom_into', *args, **kwargs
) )
def recv_into(self, *args, **kwargs): def recv_into(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'recv_info', *args, **kwargs 'recv_info', *args, **kwargs
) )
def send(self, *args, **kwargs): def send(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'send', *args, **kwargs 'send', *args, **kwargs
) )
def sendall(self, *args, **kwargs): def sendall(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'sendall', *args, **kwargs 'sendall', *args, **kwargs
) )
def sendto(self, *args, **kwargs): def sendto(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'sendto', *args, **kwargs 'sendto', *args, **kwargs
) )
def setblocking(self, *args, **kwargs): def setblocking(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'setblocking', *args, **kwargs 'setblocking', *args, **kwargs
) )
def settimeout(self, *args, **kwargs): def settimeout(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'settimeout', *args, **kwargs 'settimeout', *args, **kwargs
) )
def gettimeout(self, *args, **kwargs): def gettimeout(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'gettimeout', *args, **kwargs 'gettimeout', *args, **kwargs
) )
def setsockopt(self, *args, **kwargs): def setsockopt(self, *args, **kwargs):
return object.__getattribute__(self, r'_observedcall')( return object.__getattribute__(self, '_observedcall')(
r'setsockopt', *args, **kwargs 'setsockopt', *args, **kwargs
) )
class baseproxyobserver(object): class baseproxyobserver(object):
def _writedata(self, data): def _writedata(self, data):
if not self.logdata: if not self.logdata:
if self.logdataapis: if self.logdataapis:
self.fh.write(b'\n') self.fh.write(b'\n')
class _lrucachenode(object): class _lrucachenode(object):
"""A node in a doubly linked list. """A node in a doubly linked list.
Holds a reference to nodes on either side as well as a key-value Holds a reference to nodes on either side as well as a key-value
pair for the dictionary entry. pair for the dictionary entry.
""" """
__slots__ = (r'next', r'prev', r'key', r'value', r'cost') __slots__ = ('next', 'prev', 'key', 'value', 'cost')
def __init__(self): def __init__(self):
self.next = None self.next = None
self.prev = None self.prev = None
self.key = _notset self.key = _notset
self.value = None self.value = None
self.cost = 0 self.cost = 0

mercurial/utils/cborutil.py

SUBTYPE_SINGLE_FLOAT = 26 SUBTYPE_SINGLE_FLOAT = 26
SUBTYPE_DOUBLE_FLOAT = 27 SUBTYPE_DOUBLE_FLOAT = 27
SUBTYPE_INDEFINITE = 31 SUBTYPE_INDEFINITE = 31
SEMANTIC_TAG_FINITE_SET = 258 SEMANTIC_TAG_FINITE_SET = 258
# Indefinite types begin with their major type ORd with information value 31. # Indefinite types begin with their major type ORd with information value 31.
BEGIN_INDEFINITE_BYTESTRING = struct.pack( BEGIN_INDEFINITE_BYTESTRING = struct.pack(
r'>B', MAJOR_TYPE_BYTESTRING << 5 | SUBTYPE_INDEFINITE '>B', MAJOR_TYPE_BYTESTRING << 5 | SUBTYPE_INDEFINITE
) )
BEGIN_INDEFINITE_ARRAY = struct.pack( BEGIN_INDEFINITE_ARRAY = struct.pack(
r'>B', MAJOR_TYPE_ARRAY << 5 | SUBTYPE_INDEFINITE '>B', MAJOR_TYPE_ARRAY << 5 | SUBTYPE_INDEFINITE
) )
BEGIN_INDEFINITE_MAP = struct.pack( BEGIN_INDEFINITE_MAP = struct.pack(
r'>B', MAJOR_TYPE_MAP << 5 | SUBTYPE_INDEFINITE '>B', MAJOR_TYPE_MAP << 5 | SUBTYPE_INDEFINITE
) )
ENCODED_LENGTH_1 = struct.Struct(r'>B') ENCODED_LENGTH_1 = struct.Struct('>B')
ENCODED_LENGTH_2 = struct.Struct(r'>BB') ENCODED_LENGTH_2 = struct.Struct('>BB')
ENCODED_LENGTH_3 = struct.Struct(r'>BH') ENCODED_LENGTH_3 = struct.Struct('>BH')
ENCODED_LENGTH_4 = struct.Struct(r'>BL') ENCODED_LENGTH_4 = struct.Struct('>BL')
ENCODED_LENGTH_5 = struct.Struct(r'>BQ') ENCODED_LENGTH_5 = struct.Struct('>BQ')
# The break ends an indefinite length item. # The break ends an indefinite length item.
BREAK = b'\xff' BREAK = b'\xff'
BREAK_INT = 255 BREAK_INT = 255
def encodelength(majortype, length): def encodelength(majortype, length):
"""Obtain a value encoding the major type and its length.""" """Obtain a value encoding the major type and its length."""
else: else:
def _elementtointeger(b, i): def _elementtointeger(b, i):
return ord(b[i]) return ord(b[i])
STRUCT_BIG_UBYTE = struct.Struct(r'>B') STRUCT_BIG_UBYTE = struct.Struct('>B')
STRUCT_BIG_USHORT = struct.Struct(b'>H') STRUCT_BIG_USHORT = struct.Struct(b'>H')
STRUCT_BIG_ULONG = struct.Struct(b'>L') STRUCT_BIG_ULONG = struct.Struct(b'>L')
STRUCT_BIG_ULONGLONG = struct.Struct(b'>Q') STRUCT_BIG_ULONGLONG = struct.Struct(b'>Q')
SPECIAL_NONE = 0 SPECIAL_NONE = 0
SPECIAL_START_INDEFINITE_BYTESTRING = 1 SPECIAL_START_INDEFINITE_BYTESTRING = 1
SPECIAL_START_ARRAY = 2 SPECIAL_START_ARRAY = 2
SPECIAL_START_MAP = 3 SPECIAL_START_MAP = 3

mercurial/utils/compression.py

_ = i18n._ _ = i18n._
# compression code # compression code
SERVERROLE = b'server' SERVERROLE = b'server'
CLIENTROLE = b'client' CLIENTROLE = b'client'
compewireprotosupport = collections.namedtuple( compewireprotosupport = collections.namedtuple(
r'compenginewireprotosupport', 'compenginewireprotosupport', ('name', 'serverpriority', 'clientpriority'),
(r'name', r'serverpriority', r'clientpriority'),
) )
class propertycache(object): class propertycache(object):
def __init__(self, func): def __init__(self, func):
self.func = func self.func = func
self.name = func.__name__ self.name = func.__name__

mercurial/utils/dateutil.py

return date return date
if not formats: if not formats:
formats = defaultdateformats formats = defaultdateformats
date = date.strip() date = date.strip()
if date == b'now' or date == _(b'now'): if date == b'now' or date == _(b'now'):
return makedate() return makedate()
if date == b'today' or date == _(b'today'): if date == b'today' or date == _(b'today'):
date = datetime.date.today().strftime(r'%b %d') date = datetime.date.today().strftime('%b %d')
date = encoding.strtolocal(date) date = encoding.strtolocal(date)
elif date == b'yesterday' or date == _(b'yesterday'): elif date == b'yesterday' or date == _(b'yesterday'):
date = (datetime.date.today() - datetime.timedelta(days=1)).strftime( date = (datetime.date.today() - datetime.timedelta(days=1)).strftime(
r'%b %d' r'%b %d'
) )
date = encoding.strtolocal(date) date = encoding.strtolocal(date)
try: try:

mercurial/utils/procutil.py

from .. import ( from .. import (
encoding, encoding,
error, error,
policy, policy,
pycompat, pycompat,
) )
osutil = policy.importmod(r'osutil') osutil = policy.importmod('osutil')
stderr = pycompat.stderr stderr = pycompat.stderr
stdin = pycompat.stdin stdin = pycompat.stdin
stdout = pycompat.stdout stdout = pycompat.stdout
def isatty(fp): def isatty(fp):
try: try:
return fp.isatty() return fp.isatty()
except AttributeError: except AttributeError:
return False return False
# glibc determines buffering on first write to stdout - if we replace a TTY # glibc determines buffering on first write to stdout - if we replace a TTY
# destined stdout with a pipe destined stdout (e.g. pager), we want line # destined stdout with a pipe destined stdout (e.g. pager), we want line
# buffering (or unbuffered, on Windows) # buffering (or unbuffered, on Windows)
if isatty(stdout): if isatty(stdout):
if pycompat.iswindows: if pycompat.iswindows:
# Windows doesn't support line buffering # Windows doesn't support line buffering
stdout = os.fdopen(stdout.fileno(), r'wb', 0) stdout = os.fdopen(stdout.fileno(), 'wb', 0)
elif not pycompat.ispy3: elif not pycompat.ispy3:
# on Python 3, stdout (sys.stdout.buffer) is already line buffered and # on Python 3, stdout (sys.stdout.buffer) is already line buffered and
# buffering=1 is not handled in binary mode # buffering=1 is not handled in binary mode
stdout = os.fdopen(stdout.fileno(), r'wb', 1) stdout = os.fdopen(stdout.fileno(), 'wb', 1)
if pycompat.iswindows: if pycompat.iswindows:
from .. import windows as platform from .. import windows as platform
stdout = platform.winstdout(stdout) stdout = platform.winstdout(stdout)
else: else:
from .. import posix as platform from .. import posix as platform
def tempfilter(s, cmd): def tempfilter(s, cmd):
'''filter string S through a pair of temporary files with CMD. '''filter string S through a pair of temporary files with CMD.
CMD is used as a template to create the real command to be run, CMD is used as a template to create the real command to be run,
with the strings INFILE and OUTFILE replaced by the real names of with the strings INFILE and OUTFILE replaced by the real names of
the temporary files generated.''' the temporary files generated.'''
inname, outname = None, None inname, outname = None, None
try: try:
infd, inname = pycompat.mkstemp(prefix=b'hg-filter-in-') infd, inname = pycompat.mkstemp(prefix=b'hg-filter-in-')
fp = os.fdopen(infd, r'wb') fp = os.fdopen(infd, 'wb')
fp.write(s) fp.write(s)
fp.close() fp.close()
outfd, outname = pycompat.mkstemp(prefix=b'hg-filter-out-') outfd, outname = pycompat.mkstemp(prefix=b'hg-filter-out-')
os.close(outfd) os.close(outfd)
cmd = cmd.replace(b'INFILE', inname) cmd = cmd.replace(b'INFILE', inname)
cmd = cmd.replace(b'OUTFILE', outname) cmd = cmd.replace(b'OUTFILE', outname)
code = system(cmd) code = system(cmd)
if pycompat.sysplatform == b'OpenVMS' and code & 1: if pycompat.sysplatform == b'OpenVMS' and code & 1:
def hgexecutable(): def hgexecutable():
"""return location of the 'hg' executable. """return location of the 'hg' executable.
Defaults to $HG or 'hg' in the search path. Defaults to $HG or 'hg' in the search path.
""" """
if _hgexecutable is None: if _hgexecutable is None:
hg = encoding.environ.get(b'HG') hg = encoding.environ.get(b'HG')
mainmod = sys.modules[r'__main__'] mainmod = sys.modules['__main__']
if hg: if hg:
_sethgexecutable(hg) _sethgexecutable(hg)
elif mainfrozen(): elif mainfrozen():
if getattr(sys, 'frozen', None) == b'macosx_app': if getattr(sys, 'frozen', None) == b'macosx_app':
# Env variable set by py2app # Env variable set by py2app
_sethgexecutable(encoding.environ[b'EXECUTABLEPATH']) _sethgexecutable(encoding.environ[b'EXECUTABLEPATH'])
else: else:
_sethgexecutable(pycompat.sysexecutable) _sethgexecutable(pycompat.sysexecutable)
""" """
uout.flush() uout.flush()
fin, fout = uin, uout fin, fout = uin, uout
if _testfileno(uin, stdin): if _testfileno(uin, stdin):
newfd = os.dup(uin.fileno()) newfd = os.dup(uin.fileno())
nullfd = os.open(os.devnull, os.O_RDONLY) nullfd = os.open(os.devnull, os.O_RDONLY)
os.dup2(nullfd, uin.fileno()) os.dup2(nullfd, uin.fileno())
os.close(nullfd) os.close(nullfd)
fin = os.fdopen(newfd, r'rb') fin = os.fdopen(newfd, 'rb')
if _testfileno(uout, stdout): if _testfileno(uout, stdout):
newfd = os.dup(uout.fileno()) newfd = os.dup(uout.fileno())
os.dup2(stderr.fileno(), uout.fileno()) os.dup2(stderr.fileno(), uout.fileno())
fout = os.fdopen(newfd, r'wb') fout = os.fdopen(newfd, 'wb')
return fin, fout return fin, fout
def restorestdio(uin, uout, fin, fout): def restorestdio(uin, uout, fin, fout):
"""Restore (uin, uout) streams from possibly duplicated (fin, fout)""" """Restore (uin, uout) streams from possibly duplicated (fin, fout)"""
uout.flush() uout.flush()
for f, uif in [(fin, uin), (fout, uout)]: for f, uif in [(fin, uin), (fout, uout)]:
if f is not uif: if f is not uif:

mercurial/utils/stringutil.py

else: else:
indent = self.initial_indent indent = self.initial_indent
# Maximum width for this line. # Maximum width for this line.
width = self.width - len(indent) width = self.width - len(indent)
# First chunk on line is whitespace -- drop it, unless this # First chunk on line is whitespace -- drop it, unless this
# is the very beginning of the text (i.e. no lines started yet). # is the very beginning of the text (i.e. no lines started yet).
if self.drop_whitespace and chunks[-1].strip() == r'' and lines: if self.drop_whitespace and chunks[-1].strip() == '' and lines:
del chunks[-1] del chunks[-1]
while chunks: while chunks:
l = colwidth(chunks[-1]) l = colwidth(chunks[-1])
# Can at least squeeze this chunk onto the current line. # Can at least squeeze this chunk onto the current line.
if cur_len + l <= width: if cur_len + l <= width:
cur_line.append(chunks.pop()) cur_line.append(chunks.pop())
and cur_line and cur_line
and cur_line[-1].strip() == r'' and cur_line[-1].strip() == r''
): ):
del cur_line[-1] del cur_line[-1]
# Convert current line back to a string and store it in list # Convert current line back to a string and store it in list
# of all lines (return value). # of all lines (return value).
if cur_line: if cur_line:
lines.append(indent + r''.join(cur_line)) lines.append(indent + ''.join(cur_line))
return lines return lines
global _MBTextWrapper global _MBTextWrapper
_MBTextWrapper = tw _MBTextWrapper = tw
return tw(**kwargs) return tw(**kwargs)

mercurial/vfs.py

class closewrapbase(object): class closewrapbase(object):
"""Base class of wrapper, which hooks closing """Base class of wrapper, which hooks closing
Do not instantiate outside of the vfs layer. Do not instantiate outside of the vfs layer.
""" """
def __init__(self, fh): def __init__(self, fh):
object.__setattr__(self, r'_origfh', fh) object.__setattr__(self, '_origfh', fh)
def __getattr__(self, attr): def __getattr__(self, attr):
return getattr(self._origfh, attr) return getattr(self._origfh, attr)
def __setattr__(self, attr, value): def __setattr__(self, attr, value):
return setattr(self._origfh, attr, value) return setattr(self._origfh, attr, value)
def __delattr__(self, attr): def __delattr__(self, attr):
class delayclosedfile(closewrapbase): class delayclosedfile(closewrapbase):
"""Proxy for a file object whose close is delayed. """Proxy for a file object whose close is delayed.
Do not instantiate outside of the vfs layer. Do not instantiate outside of the vfs layer.
""" """
def __init__(self, fh, closer): def __init__(self, fh, closer):
super(delayclosedfile, self).__init__(fh) super(delayclosedfile, self).__init__(fh)
object.__setattr__(self, r'_closer', closer) object.__setattr__(self, '_closer', closer)
def __exit__(self, exc_type, exc_value, exc_tb): def __exit__(self, exc_type, exc_value, exc_tb):
self._closer.close(self._origfh) self._closer.close(self._origfh)
def close(self): def close(self):
self._closer.close(self._origfh) self._closer.close(self._origfh)
This proxy is useful only if the target file is guarded by any This proxy is useful only if the target file is guarded by any
lock (e.g. repo.lock or repo.wlock) lock (e.g. repo.lock or repo.wlock)
Do not instantiate outside of the vfs layer. Do not instantiate outside of the vfs layer.
""" """
def __init__(self, fh): def __init__(self, fh):
super(checkambigatclosing, self).__init__(fh) super(checkambigatclosing, self).__init__(fh)
object.__setattr__(self, r'_oldstat', util.filestat.frompath(fh.name)) object.__setattr__(self, '_oldstat', util.filestat.frompath(fh.name))
def _checkambig(self): def _checkambig(self):
oldstat = self._oldstat oldstat = self._oldstat
if oldstat.stat: if oldstat.stat:
_avoidambig(self._origfh.name, oldstat) _avoidambig(self._origfh.name, oldstat)
def __exit__(self, exc_type, exc_value, exc_tb): def __exit__(self, exc_type, exc_value, exc_tb):
self._origfh.__exit__(exc_type, exc_value, exc_tb) self._origfh.__exit__(exc_type, exc_value, exc_tb)
self._checkambig() self._checkambig()
def close(self): def close(self):
self._origfh.close() self._origfh.close()
self._checkambig() self._checkambig()

mercurial/win32.py

_WPARAM = ctypes.c_ulong _WPARAM = ctypes.c_ulong
_LPARAM = ctypes.c_long _LPARAM = ctypes.c_long
elif ctypes.sizeof(ctypes.c_longlong) == ctypes.sizeof(ctypes.c_void_p): elif ctypes.sizeof(ctypes.c_longlong) == ctypes.sizeof(ctypes.c_void_p):
_WPARAM = ctypes.c_ulonglong _WPARAM = ctypes.c_ulonglong
_LPARAM = ctypes.c_longlong _LPARAM = ctypes.c_longlong
class _FILETIME(ctypes.Structure): class _FILETIME(ctypes.Structure):
_fields_ = [(r'dwLowDateTime', _DWORD), (r'dwHighDateTime', _DWORD)] _fields_ = [('dwLowDateTime', _DWORD), ('dwHighDateTime', _DWORD)]
class _BY_HANDLE_FILE_INFORMATION(ctypes.Structure): class _BY_HANDLE_FILE_INFORMATION(ctypes.Structure):
_fields_ = [ _fields_ = [
(r'dwFileAttributes', _DWORD), ('dwFileAttributes', _DWORD),
(r'ftCreationTime', _FILETIME), ('ftCreationTime', _FILETIME),
(r'ftLastAccessTime', _FILETIME), ('ftLastAccessTime', _FILETIME),
(r'ftLastWriteTime', _FILETIME), ('ftLastWriteTime', _FILETIME),
(r'dwVolumeSerialNumber', _DWORD), ('dwVolumeSerialNumber', _DWORD),
(r'nFileSizeHigh', _DWORD), ('nFileSizeHigh', _DWORD),
(r'nFileSizeLow', _DWORD), ('nFileSizeLow', _DWORD),
(r'nNumberOfLinks', _DWORD), ('nNumberOfLinks', _DWORD),
(r'nFileIndexHigh', _DWORD), ('nFileIndexHigh', _DWORD),
(r'nFileIndexLow', _DWORD), ('nFileIndexLow', _DWORD),
] ]
# CreateFile # CreateFile
_FILE_SHARE_READ = 0x00000001 _FILE_SHARE_READ = 0x00000001
_FILE_SHARE_WRITE = 0x00000002 _FILE_SHARE_WRITE = 0x00000002
_FILE_SHARE_DELETE = 0x00000004 _FILE_SHARE_DELETE = 0x00000004
_PROCESS_QUERY_INFORMATION = 0x0400 _PROCESS_QUERY_INFORMATION = 0x0400
# GetExitCodeProcess # GetExitCodeProcess
_STILL_ACTIVE = 259 _STILL_ACTIVE = 259
class _STARTUPINFO(ctypes.Structure): class _STARTUPINFO(ctypes.Structure):
_fields_ = [ _fields_ = [
(r'cb', _DWORD), ('cb', _DWORD),
(r'lpReserved', _LPSTR), ('lpReserved', _LPSTR),
(r'lpDesktop', _LPSTR), ('lpDesktop', _LPSTR),
(r'lpTitle', _LPSTR), ('lpTitle', _LPSTR),
(r'dwX', _DWORD), ('dwX', _DWORD),
(r'dwY', _DWORD), ('dwY', _DWORD),
(r'dwXSize', _DWORD), ('dwXSize', _DWORD),
(r'dwYSize', _DWORD), ('dwYSize', _DWORD),
(r'dwXCountChars', _DWORD), ('dwXCountChars', _DWORD),
(r'dwYCountChars', _DWORD), ('dwYCountChars', _DWORD),
(r'dwFillAttribute', _DWORD), ('dwFillAttribute', _DWORD),
(r'dwFlags', _DWORD), ('dwFlags', _DWORD),
(r'wShowWindow', _WORD), ('wShowWindow', _WORD),
(r'cbReserved2', _WORD), ('cbReserved2', _WORD),
(r'lpReserved2', ctypes.c_char_p), ('lpReserved2', ctypes.c_char_p),
(r'hStdInput', _HANDLE), ('hStdInput', _HANDLE),
(r'hStdOutput', _HANDLE), ('hStdOutput', _HANDLE),
(r'hStdError', _HANDLE), ('hStdError', _HANDLE),
] ]
class _PROCESS_INFORMATION(ctypes.Structure): class _PROCESS_INFORMATION(ctypes.Structure):
_fields_ = [ _fields_ = [
(r'hProcess', _HANDLE), ('hProcess', _HANDLE),
(r'hThread', _HANDLE), ('hThread', _HANDLE),
(r'dwProcessId', _DWORD), ('dwProcessId', _DWORD),
(r'dwThreadId', _DWORD), ('dwThreadId', _DWORD),
] ]
_CREATE_NO_WINDOW = 0x08000000 _CREATE_NO_WINDOW = 0x08000000
_SW_HIDE = 0 _SW_HIDE = 0
class _COORD(ctypes.Structure): class _COORD(ctypes.Structure):
_fields_ = [(r'X', ctypes.c_short), (r'Y', ctypes.c_short)] _fields_ = [('X', ctypes.c_short), ('Y', ctypes.c_short)]
class _SMALL_RECT(ctypes.Structure): class _SMALL_RECT(ctypes.Structure):
_fields_ = [ _fields_ = [
(r'Left', ctypes.c_short), ('Left', ctypes.c_short),
(r'Top', ctypes.c_short), ('Top', ctypes.c_short),
(r'Right', ctypes.c_short), ('Right', ctypes.c_short),
(r'Bottom', ctypes.c_short), ('Bottom', ctypes.c_short),
] ]
class _CONSOLE_SCREEN_BUFFER_INFO(ctypes.Structure): class _CONSOLE_SCREEN_BUFFER_INFO(ctypes.Structure):
_fields_ = [ _fields_ = [
(r'dwSize', _COORD), ('dwSize', _COORD),
(r'dwCursorPosition', _COORD), ('dwCursorPosition', _COORD),
(r'wAttributes', _WORD), ('wAttributes', _WORD),
(r'srWindow', _SMALL_RECT), ('srWindow', _SMALL_RECT),
(r'dwMaximumWindowSize', _COORD), ('dwMaximumWindowSize', _COORD),
] ]
_STD_OUTPUT_HANDLE = _DWORD(-11).value _STD_OUTPUT_HANDLE = _DWORD(-11).value
_STD_ERROR_HANDLE = _DWORD(-12).value _STD_ERROR_HANDLE = _DWORD(-12).value
# CERT_TRUST_STATUS dwErrorStatus # CERT_TRUST_STATUS dwErrorStatus
CERT_TRUST_IS_PARTIAL_CHAIN = 0x10000 CERT_TRUST_IS_PARTIAL_CHAIN = 0x10000
def _raiseoserror(name): def _raiseoserror(name):
# Force the code to a signed int to avoid an 'int too large' error. # Force the code to a signed int to avoid an 'int too large' error.
# See https://bugs.python.org/issue28474 # See https://bugs.python.org/issue28474
code = _kernel32.GetLastError() code = _kernel32.GetLastError()
if code > 0x7FFFFFFF: if code > 0x7FFFFFFF:
code -= 2 ** 32 code -= 2 ** 32
err = ctypes.WinError(code=code) err = ctypes.WinError(code=code)
raise OSError( raise OSError(
err.errno, r'%s: %s' % (encoding.strfromlocal(name), err.strerror) err.errno, '%s: %s' % (encoding.strfromlocal(name), err.strerror)
) )
def _getfileinfo(name): def _getfileinfo(name):
fh = _kernel32.CreateFileA( fh = _kernel32.CreateFileA(
name, name,
0, 0,
_FILE_SHARE_READ | _FILE_SHARE_WRITE | _FILE_SHARE_DELETE, _FILE_SHARE_READ | _FILE_SHARE_WRITE | _FILE_SHARE_DELETE,

mercurial/windows.py

try: try:
import _winreg as winreg import _winreg as winreg
winreg.CloseKey winreg.CloseKey
except ImportError: except ImportError:
import winreg import winreg
osutil = policy.importmod(r'osutil') osutil = policy.importmod('osutil')
getfsmountpoint = win32.getvolumename getfsmountpoint = win32.getvolumename
getfstype = win32.getfstype getfstype = win32.getfstype
getuser = win32.getuser getuser = win32.getuser
hidewindow = win32.hidewindow hidewindow = win32.hidewindow
makedir = win32.makedir makedir = win32.makedir
nlinks = win32.nlinks nlinks = win32.nlinks
oslink = win32.oslink oslink = win32.oslink
calls when necessary. calls when necessary.
""" """
OPNONE = 0 OPNONE = 0
OPREAD = 1 OPREAD = 1
OPWRITE = 2 OPWRITE = 2
def __init__(self, fp): def __init__(self, fp):
object.__setattr__(self, r'_fp', fp) object.__setattr__(self, '_fp', fp)
object.__setattr__(self, r'_lastop', 0) object.__setattr__(self, '_lastop', 0)
def __enter__(self): def __enter__(self):
self._fp.__enter__() self._fp.__enter__()
return self return self
def __exit__(self, exc_type, exc_val, exc_tb): def __exit__(self, exc_type, exc_val, exc_tb):
self._fp.__exit__(exc_type, exc_val, exc_tb) self._fp.__exit__(exc_type, exc_val, exc_tb)
def __getattr__(self, name): def __getattr__(self, name):
return getattr(self._fp, name) return getattr(self._fp, name)
def __setattr__(self, name, value): def __setattr__(self, name, value):
return self._fp.__setattr__(name, value) return self._fp.__setattr__(name, value)
def _noopseek(self): def _noopseek(self):
self._fp.seek(0, os.SEEK_CUR) self._fp.seek(0, os.SEEK_CUR)
def seek(self, *args, **kwargs): def seek(self, *args, **kwargs):
object.__setattr__(self, r'_lastop', self.OPNONE) object.__setattr__(self, '_lastop', self.OPNONE)
return self._fp.seek(*args, **kwargs) return self._fp.seek(*args, **kwargs)
def write(self, d): def write(self, d):
if self._lastop == self.OPREAD: if self._lastop == self.OPREAD:
self._noopseek() self._noopseek()
object.__setattr__(self, r'_lastop', self.OPWRITE) object.__setattr__(self, '_lastop', self.OPWRITE)
return self._fp.write(d) return self._fp.write(d)
def writelines(self, *args, **kwargs): def writelines(self, *args, **kwargs):
if self._lastop == self.OPREAD: if self._lastop == self.OPREAD:
self._noopeseek() self._noopeseek()
object.__setattr__(self, r'_lastop', self.OPWRITE) object.__setattr__(self, '_lastop', self.OPWRITE)
return self._fp.writelines(*args, **kwargs) return self._fp.writelines(*args, **kwargs)
def read(self, *args, **kwargs): def read(self, *args, **kwargs):
if self._lastop == self.OPWRITE: if self._lastop == self.OPWRITE:
self._noopseek() self._noopseek()
object.__setattr__(self, r'_lastop', self.OPREAD) object.__setattr__(self, '_lastop', self.OPREAD)
return self._fp.read(*args, **kwargs) return self._fp.read(*args, **kwargs)
def readline(self, *args, **kwargs): def readline(self, *args, **kwargs):
if self._lastop == self.OPWRITE: if self._lastop == self.OPWRITE:
self._noopseek() self._noopseek()
object.__setattr__(self, r'_lastop', self.OPREAD) object.__setattr__(self, '_lastop', self.OPREAD)
return self._fp.readline(*args, **kwargs) return self._fp.readline(*args, **kwargs)
def readlines(self, *args, **kwargs): def readlines(self, *args, **kwargs):
if self._lastop == self.OPWRITE: if self._lastop == self.OPWRITE:
self._noopseek() self._noopseek()
object.__setattr__(self, r'_lastop', self.OPREAD) object.__setattr__(self, '_lastop', self.OPREAD)
return self._fp.readlines(*args, **kwargs) return self._fp.readlines(*args, **kwargs)
class fdproxy(object): class fdproxy(object):
"""Wraps osutil.posixfile() to override the name attribute to reflect the """Wraps osutil.posixfile() to override the name attribute to reflect the
underlying file name. underlying file name.
""" """
if b'+' in mode: if b'+' in mode:
return mixedfilemodewrapper(fp) return mixedfilemodewrapper(fp)
return fp return fp
except WindowsError as err: except WindowsError as err:
# convert to a friendlier exception # convert to a friendlier exception
raise IOError( raise IOError(
err.errno, r'%s: %s' % (encoding.strfromlocal(name), err.strerror) err.errno, '%s: %s' % (encoding.strfromlocal(name), err.strerror)
) )
# may be wrapped by win32mbcs extension # may be wrapped by win32mbcs extension
listdir = osutil.listdir listdir = osutil.listdir
class winstdout(object): class winstdout(object):
while start < l: while start < l:
end = start + limit end = start + limit
self.fp.write(s[start:end]) self.fp.write(s[start:end])
start = end start = end
except IOError as inst: except IOError as inst:
if inst.errno != 0 and not win32.lasterrorwaspipeerror(inst): if inst.errno != 0 and not win32.lasterrorwaspipeerror(inst):
raise raise
self.close() self.close()
raise IOError(errno.EPIPE, r'Broken pipe') raise IOError(errno.EPIPE, 'Broken pipe')
def flush(self): def flush(self):
try: try:
return self.fp.flush() return self.fp.flush()
except IOError as inst: except IOError as inst:
if not win32.lasterrorwaspipeerror(inst): if not win32.lasterrorwaspipeerror(inst):
raise raise
raise IOError(errno.EPIPE, r'Broken pipe') raise IOError(errno.EPIPE, 'Broken pipe')
def _is_win_9x(): def _is_win_9x():
'''return true if run on windows 95, 98 or me.''' '''return true if run on windows 95, 98 or me.'''
try: try:
return sys.getwindowsversion()[3] == 1 return sys.getwindowsversion()[3] == 1
except AttributeError: except AttributeError:
return b'command' in encoding.environ.get(b'comspec', b'') return b'command' in encoding.environ.get(b'comspec', b'')
if not s: if not s:
break break
chunks.append(s) chunks.append(s)
return b''.join(chunks) return b''.join(chunks)
def bindunixsocket(sock, path): def bindunixsocket(sock, path):
raise NotImplementedError(r'unsupported platform') raise NotImplementedError('unsupported platform')

mercurial/wireprotoframing.py

FRAME_TYPE_COMMAND_RESPONSE: FLAGS_COMMAND_RESPONSE, FRAME_TYPE_COMMAND_RESPONSE: FLAGS_COMMAND_RESPONSE,
FRAME_TYPE_ERROR_RESPONSE: {}, FRAME_TYPE_ERROR_RESPONSE: {},
FRAME_TYPE_TEXT_OUTPUT: {}, FRAME_TYPE_TEXT_OUTPUT: {},
FRAME_TYPE_PROGRESS: {}, FRAME_TYPE_PROGRESS: {},
FRAME_TYPE_SENDER_PROTOCOL_SETTINGS: FLAGS_SENDER_PROTOCOL_SETTINGS, FRAME_TYPE_SENDER_PROTOCOL_SETTINGS: FLAGS_SENDER_PROTOCOL_SETTINGS,
FRAME_TYPE_STREAM_SETTINGS: FLAGS_STREAM_ENCODING_SETTINGS, FRAME_TYPE_STREAM_SETTINGS: FLAGS_STREAM_ENCODING_SETTINGS,
} }
ARGUMENT_RECORD_HEADER = struct.Struct(r'<HH') ARGUMENT_RECORD_HEADER = struct.Struct('<HH')
def humanflags(mapping, value): def humanflags(mapping, value):
"""Convert a numeric flags value to a human value, using a mapping table.""" """Convert a numeric flags value to a human value, using a mapping table."""
namemap = {v: k for k, v in pycompat.iteritems(mapping)} namemap = {v: k for k, v in pycompat.iteritems(mapping)}
flags = [] flags = []
val = 1 val = 1
while value >= val: while value >= val:
# 24 bits length # 24 bits length
# 16 bits request id # 16 bits request id
# 8 bits stream id # 8 bits stream id
# 8 bits stream flags # 8 bits stream flags
# 4 bits type # 4 bits type
# 4 bits flags # 4 bits flags
l = struct.pack(r'<I', len(payload)) l = struct.pack('<I', len(payload))
frame[0:3] = l[0:3] frame[0:3] = l[0:3]
struct.pack_into(r'<HBB', frame, 3, requestid, streamid, streamflags) struct.pack_into('<HBB', frame, 3, requestid, streamid, streamflags)
frame[7] = (typeid << 4) | flags frame[7] = (typeid << 4) | flags
frame[8:] = payload frame[8:] = payload
return frame return frame
def makeframefromhumanstring(s): def makeframefromhumanstring(s):
"""Create a frame from a human readable string """Create a frame from a human readable string
# 24 bits payload length (little endian) # 24 bits payload length (little endian)
# 16 bits request ID # 16 bits request ID
# 8 bits stream ID # 8 bits stream ID
# 8 bits stream flags # 8 bits stream flags
# 4 bits frame type # 4 bits frame type
# 4 bits frame flags # 4 bits frame flags
# ... payload # ... payload
framelength = data[0] + 256 * data[1] + 16384 * data[2] framelength = data[0] + 256 * data[1] + 16384 * data[2]
requestid, streamid, streamflags = struct.unpack_from(r'<HBB', data, 3) requestid, streamid, streamflags = struct.unpack_from('<HBB', data, 3)
typeflags = data[7] typeflags = data[7]
frametype = (typeflags & 0xF0) >> 4 frametype = (typeflags & 0xF0) >> 4
frameflags = typeflags & 0x0F frameflags = typeflags & 0x0F
return frameheader( return frameheader(
framelength, requestid, streamid, streamflags, frametype, frameflags framelength, requestid, streamid, streamflags, frametype, frameflags
) )
def createalternatelocationresponseframe(stream, requestid, location): def createalternatelocationresponseframe(stream, requestid, location):
data = { data = {
b'status': b'redirect', b'status': b'redirect',
b'location': {b'url': location.url, b'mediatype': location.mediatype,}, b'location': {b'url': location.url, b'mediatype': location.mediatype,},
} }
for a in ( for a in (
r'size', 'size',
r'fullhashes', 'fullhashes',
r'fullhashseed', 'fullhashseed',
r'serverdercerts', 'serverdercerts',
r'servercadercerts', 'servercadercerts',
): ):
value = getattr(location, a) value = getattr(location, a)
if value is not None: if value is not None:
data[b'location'][pycompat.bytestr(a)] = value data[b'location'][pycompat.bytestr(a)] = value
payload = b''.join(cborutil.streamencode(data)) payload = b''.join(cborutil.streamencode(data))
if stream.streamsettingssent: if stream.streamsettingssent:
for arg in args: for arg in args:
if not isinstance(arg, bytes): if not isinstance(arg, bytes):
raise ValueError(b'must use bytes for arguments') raise ValueError(b'must use bytes for arguments')
for label in labels: for label in labels:
if not isinstance(label, bytes): if not isinstance(label, bytes):
raise ValueError(b'must use bytes for labels') raise ValueError(b'must use bytes for labels')
# Formatting string must be ASCII. # Formatting string must be ASCII.
formatting = formatting.decode(r'ascii', r'replace').encode(r'ascii') formatting = formatting.decode('ascii', 'replace').encode('ascii')
# Arguments must be UTF-8. # Arguments must be UTF-8.
args = [a.decode(r'utf-8', r'replace').encode(r'utf-8') for a in args] args = [a.decode('utf-8', 'replace').encode('utf-8') for a in args]
# Labels must be ASCII. # Labels must be ASCII.
labels = [ labels = [l.decode('ascii', 'strict').encode('ascii') for l in labels]
l.decode(r'ascii', r'strict').encode(r'ascii') for l in labels
]
atom = {b'msg': formatting} atom = {b'msg': formatting}
if args: if args:
atom[b'args'] = args atom[b'args'] = args
if labels: if labels:
atom[b'labels'] = labels atom[b'labels'] = labels
atomdicts.append(atom) atomdicts.append(atom)

mercurial/wireprotov1peer.py

def _submitone(self, op, args): def _submitone(self, op, args):
return self._call(op, **pycompat.strkwargs(args)) return self._call(op, **pycompat.strkwargs(args))
def debugwireargs(self, one, two, three=None, four=None, five=None): def debugwireargs(self, one, two, three=None, four=None, five=None):
# don't pass optional arguments left at their default value # don't pass optional arguments left at their default value
opts = {} opts = {}
if three is not None: if three is not None:
opts[r'three'] = three opts['three'] = three
if four is not None: if four is not None:
opts[r'four'] = four opts['four'] = four
return self._call(b'debugwireargs', one=one, two=two, **opts) return self._call(b'debugwireargs', one=one, two=two, **opts)
def _call(self, cmd, **args): def _call(self, cmd, **args):
"""execute <cmd> on the server """execute <cmd> on the server
The command is expected to return a simple string. The command is expected to return a simple string.
returns the server reply as a string.""" returns the server reply as a string."""

mercurial/wireprotov2peer.py

self._ui.warn( self._ui.warn(
_( _(
b'(support for pinning server certificates on ' b'(support for pinning server certificates on '
b'content redirects not supported)\n' b'content redirects not supported)\n'
) )
) )
headers = { headers = {
r'Accept': redirect.mediatype, 'Accept': redirect.mediatype,
} }
req = self._requestbuilder(pycompat.strurl(redirect.url), None, headers) req = self._requestbuilder(pycompat.strurl(redirect.url), None, headers)
try: try:
res = self._opener.open(req) res = self._opener.open(req)
except util.urlerr.httperror as e: except util.urlerr.httperror as e:
if e.code == 401: if e.code == 401:

mercurial/worker.py

) )
def countcpus(): def countcpus():
'''try to count the number of CPUs on the system''' '''try to count the number of CPUs on the system'''
# posix # posix
try: try:
n = int(os.sysconf(r'SC_NPROCESSORS_ONLN')) n = int(os.sysconf('SC_NPROCESSORS_ONLN'))
if n > 0: if n > 0:
return n return n
except (AttributeError, ValueError): except (AttributeError, ValueError):
pass pass
# windows # windows
try: try:
n = int(encoding.environ[b'NUMBER_OF_PROCESSORS']) n = int(encoding.environ[b'NUMBER_OF_PROCESSORS'])
except: # never returns, no re-raises except: # never returns, no re-raises
pass pass
finally: finally:
os._exit(ret & 255) os._exit(ret & 255)
pids.add(pid) pids.add(pid)
selector = selectors.DefaultSelector() selector = selectors.DefaultSelector()
for rfd, wfd in pipes: for rfd, wfd in pipes:
os.close(wfd) os.close(wfd)
selector.register(os.fdopen(rfd, r'rb', 0), selectors.EVENT_READ) selector.register(os.fdopen(rfd, 'rb', 0), selectors.EVENT_READ)
def cleanup(): def cleanup():
signal.signal(signal.SIGINT, oldhandler) signal.signal(signal.SIGINT, oldhandler)
waitforworkers() waitforworkers()
signal.signal(signal.SIGCHLD, oldchldhandler) signal.signal(signal.SIGCHLD, oldchldhandler)
selector.close() selector.close()
return problem[0] return problem[0]

tests/fakedirstatewritetime.py

configtable = {} configtable = {}
configitem = registrar.configitem(configtable) configitem = registrar.configitem(configtable)
configitem( configitem(
b'fakedirstatewritetime', b'fakenow', default=None, b'fakedirstatewritetime', b'fakenow', default=None,
) )
parsers = policy.importmod(r'parsers') parsers = policy.importmod('parsers')
rustmod = policy.importrust(r'parsers') rustmod = policy.importrust('parsers')
def pack_dirstate(fakenow, orig, dmap, copymap, pl, now): def pack_dirstate(fakenow, orig, dmap, copymap, pl, now):
# execute what original parsers.pack_dirstate should do actually # execute what original parsers.pack_dirstate should do actually
# for consistency # for consistency
actualnow = int(now) actualnow = int(now)
for f, e in dmap.items(): for f, e in dmap.items():
if e[0] == 'n' and e[3] == actualnow: if e[0] == 'n' and e[3] == actualnow:

tests/pullext.py

error, error,
extensions, extensions,
localrepo, localrepo,
) )
from mercurial.interfaces import repository from mercurial.interfaces import repository
def clonecommand(orig, ui, repo, *args, **kwargs): def clonecommand(orig, ui, repo, *args, **kwargs):
if kwargs.get(r'include') or kwargs.get(r'exclude'): if kwargs.get('include') or kwargs.get('exclude'):
kwargs[r'narrow'] = True kwargs['narrow'] = True
if kwargs.get(r'depth'): if kwargs.get('depth'):
try: try:
kwargs[r'depth'] = int(kwargs[r'depth']) kwargs['depth'] = int(kwargs['depth'])
except ValueError: except ValueError:
raise error.Abort(_('--depth must be an integer')) raise error.Abort(_('--depth must be an integer'))
return orig(ui, repo, *args, **kwargs) return orig(ui, repo, *args, **kwargs)
def featuresetup(ui, features): def featuresetup(ui, features):
features.add(repository.NARROW_REQUIREMENT) features.add(repository.NARROW_REQUIREMENT)

tests/test-parseindex2.py

nullrev, nullrev,
) )
from mercurial import ( from mercurial import (
node as nodemod, node as nodemod,
policy, policy,
pycompat, pycompat,
) )
parsers = policy.importmod(r'parsers') parsers = policy.importmod('parsers')
# original python implementation # original python implementation
def gettype(q): def gettype(q):
return int(q & 0xFFFF) return int(q & 0xFFFF)
def offset_type(offset, type): def offset_type(offset, type):
return int(int(offset) << 16 | type) return int(int(offset) << 16 | type)

tests/test-wsgirequest.py

from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
import unittest import unittest
from mercurial.hgweb import request as requestmod from mercurial.hgweb import request as requestmod
from mercurial import error from mercurial import error
DEFAULT_ENV = { DEFAULT_ENV = {
r'REQUEST_METHOD': r'GET', 'REQUEST_METHOD': 'GET',
r'SERVER_NAME': r'testserver', 'SERVER_NAME': 'testserver',
r'SERVER_PORT': r'80', 'SERVER_PORT': '80',
r'SERVER_PROTOCOL': r'http', 'SERVER_PROTOCOL': 'http',
r'wsgi.version': (1, 0), 'wsgi.version': (1, 0),
r'wsgi.url_scheme': r'http', 'wsgi.url_scheme': 'http',
r'wsgi.input': None, 'wsgi.input': None,
r'wsgi.errors': None, 'wsgi.errors': None,
r'wsgi.multithread': False, 'wsgi.multithread': False,
r'wsgi.multiprocess': True, 'wsgi.multiprocess': True,
r'wsgi.run_once': False, 'wsgi.run_once': False,
} }
def parse(env, reponame=None, altbaseurl=None, extra=None): def parse(env, reponame=None, altbaseurl=None, extra=None):
env = dict(env) env = dict(env)
env.update(extra or {}) env.update(extra or {})
return requestmod.parserequestfromenv( return requestmod.parserequestfromenv(
self.assertEqual(r.dispatchparts, []) self.assertEqual(r.dispatchparts, [])
self.assertIsNone(r.dispatchpath) self.assertIsNone(r.dispatchpath)
self.assertIsNone(r.reponame) self.assertIsNone(r.reponame)
self.assertEqual(r.querystring, b'') self.assertEqual(r.querystring, b'')
self.assertEqual(len(r.qsparams), 0) self.assertEqual(len(r.qsparams), 0)
self.assertEqual(len(r.headers), 0) self.assertEqual(len(r.headers), 0)
def testcustomport(self): def testcustomport(self):
r = parse(DEFAULT_ENV, extra={r'SERVER_PORT': r'8000',}) r = parse(DEFAULT_ENV, extra={'SERVER_PORT': '8000',})
self.assertEqual(r.url, b'http://testserver:8000') self.assertEqual(r.url, b'http://testserver:8000')
self.assertEqual(r.baseurl, b'http://testserver:8000') self.assertEqual(r.baseurl, b'http://testserver:8000')
self.assertEqual(r.advertisedurl, b'http://testserver:8000') self.assertEqual(r.advertisedurl, b'http://testserver:8000')
self.assertEqual(r.advertisedbaseurl, b'http://testserver:8000') self.assertEqual(r.advertisedbaseurl, b'http://testserver:8000')
r = parse( r = parse(
DEFAULT_ENV, DEFAULT_ENV,
extra={r'SERVER_PORT': r'4000', r'wsgi.url_scheme': r'https',}, extra={'SERVER_PORT': '4000', 'wsgi.url_scheme': 'https',},
) )
self.assertEqual(r.url, b'https://testserver:4000') self.assertEqual(r.url, b'https://testserver:4000')
self.assertEqual(r.baseurl, b'https://testserver:4000') self.assertEqual(r.baseurl, b'https://testserver:4000')
self.assertEqual(r.advertisedurl, b'https://testserver:4000') self.assertEqual(r.advertisedurl, b'https://testserver:4000')
self.assertEqual(r.advertisedbaseurl, b'https://testserver:4000') self.assertEqual(r.advertisedbaseurl, b'https://testserver:4000')
def testhttphost(self): def testhttphost(self):
r = parse(DEFAULT_ENV, extra={r'HTTP_HOST': r'altserver',}) r = parse(DEFAULT_ENV, extra={'HTTP_HOST': 'altserver',})
self.assertEqual(r.url, b'http://altserver') self.assertEqual(r.url, b'http://altserver')
self.assertEqual(r.baseurl, b'http://altserver') self.assertEqual(r.baseurl, b'http://altserver')
self.assertEqual(r.advertisedurl, b'http://testserver') self.assertEqual(r.advertisedurl, b'http://testserver')
self.assertEqual(r.advertisedbaseurl, b'http://testserver') self.assertEqual(r.advertisedbaseurl, b'http://testserver')
def testscriptname(self): def testscriptname(self):
r = parse(DEFAULT_ENV, extra={r'SCRIPT_NAME': r'',}) r = parse(DEFAULT_ENV, extra={'SCRIPT_NAME': '',})
self.assertEqual(r.url, b'http://testserver') self.assertEqual(r.url, b'http://testserver')
self.assertEqual(r.baseurl, b'http://testserver') self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl, b'http://testserver') self.assertEqual(r.advertisedurl, b'http://testserver')
self.assertEqual(r.advertisedbaseurl, b'http://testserver') self.assertEqual(r.advertisedbaseurl, b'http://testserver')
self.assertEqual(r.apppath, b'') self.assertEqual(r.apppath, b'')
self.assertEqual(r.dispatchparts, []) self.assertEqual(r.dispatchparts, [])
self.assertIsNone(r.dispatchpath) self.assertIsNone(r.dispatchpath)
r = parse(DEFAULT_ENV, extra={r'SCRIPT_NAME': r'/script',}) r = parse(DEFAULT_ENV, extra={'SCRIPT_NAME': '/script',})
self.assertEqual(r.url, b'http://testserver/script') self.assertEqual(r.url, b'http://testserver/script')
self.assertEqual(r.baseurl, b'http://testserver') self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl, b'http://testserver/script') self.assertEqual(r.advertisedurl, b'http://testserver/script')
self.assertEqual(r.advertisedbaseurl, b'http://testserver') self.assertEqual(r.advertisedbaseurl, b'http://testserver')
self.assertEqual(r.apppath, b'/script') self.assertEqual(r.apppath, b'/script')
self.assertEqual(r.dispatchparts, []) self.assertEqual(r.dispatchparts, [])
self.assertIsNone(r.dispatchpath) self.assertIsNone(r.dispatchpath)
r = parse(DEFAULT_ENV, extra={r'SCRIPT_NAME': r'/multiple words',}) r = parse(DEFAULT_ENV, extra={'SCRIPT_NAME': '/multiple words',})
self.assertEqual(r.url, b'http://testserver/multiple%20words') self.assertEqual(r.url, b'http://testserver/multiple%20words')
self.assertEqual(r.baseurl, b'http://testserver') self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl, b'http://testserver/multiple%20words') self.assertEqual(r.advertisedurl, b'http://testserver/multiple%20words')
self.assertEqual(r.advertisedbaseurl, b'http://testserver') self.assertEqual(r.advertisedbaseurl, b'http://testserver')
self.assertEqual(r.apppath, b'/multiple words') self.assertEqual(r.apppath, b'/multiple words')
self.assertEqual(r.dispatchparts, []) self.assertEqual(r.dispatchparts, [])
self.assertIsNone(r.dispatchpath) self.assertIsNone(r.dispatchpath)
def testpathinfo(self): def testpathinfo(self):
r = parse(DEFAULT_ENV, extra={r'PATH_INFO': r'',}) r = parse(DEFAULT_ENV, extra={'PATH_INFO': '',})
self.assertEqual(r.url, b'http://testserver') self.assertEqual(r.url, b'http://testserver')
self.assertEqual(r.baseurl, b'http://testserver') self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl, b'http://testserver') self.assertEqual(r.advertisedurl, b'http://testserver')
self.assertEqual(r.advertisedbaseurl, b'http://testserver') self.assertEqual(r.advertisedbaseurl, b'http://testserver')
self.assertEqual(r.apppath, b'') self.assertEqual(r.apppath, b'')
self.assertEqual(r.dispatchparts, []) self.assertEqual(r.dispatchparts, [])
self.assertEqual(r.dispatchpath, b'') self.assertEqual(r.dispatchpath, b'')
r = parse(DEFAULT_ENV, extra={r'PATH_INFO': r'/pathinfo',}) r = parse(DEFAULT_ENV, extra={'PATH_INFO': '/pathinfo',})
self.assertEqual(r.url, b'http://testserver/pathinfo') self.assertEqual(r.url, b'http://testserver/pathinfo')
self.assertEqual(r.baseurl, b'http://testserver') self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl, b'http://testserver/pathinfo') self.assertEqual(r.advertisedurl, b'http://testserver/pathinfo')
self.assertEqual(r.advertisedbaseurl, b'http://testserver') self.assertEqual(r.advertisedbaseurl, b'http://testserver')
self.assertEqual(r.apppath, b'') self.assertEqual(r.apppath, b'')
self.assertEqual(r.dispatchparts, [b'pathinfo']) self.assertEqual(r.dispatchparts, [b'pathinfo'])
self.assertEqual(r.dispatchpath, b'pathinfo') self.assertEqual(r.dispatchpath, b'pathinfo')
r = parse(DEFAULT_ENV, extra={r'PATH_INFO': r'/one/two/',}) r = parse(DEFAULT_ENV, extra={'PATH_INFO': '/one/two/',})
self.assertEqual(r.url, b'http://testserver/one/two/') self.assertEqual(r.url, b'http://testserver/one/two/')
self.assertEqual(r.baseurl, b'http://testserver') self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl, b'http://testserver/one/two/') self.assertEqual(r.advertisedurl, b'http://testserver/one/two/')
self.assertEqual(r.advertisedbaseurl, b'http://testserver') self.assertEqual(r.advertisedbaseurl, b'http://testserver')
self.assertEqual(r.apppath, b'') self.assertEqual(r.apppath, b'')
self.assertEqual(r.dispatchparts, [b'one', b'two']) self.assertEqual(r.dispatchparts, [b'one', b'two'])
self.assertEqual(r.dispatchpath, b'one/two') self.assertEqual(r.dispatchpath, b'one/two')
def testscriptandpathinfo(self): def testscriptandpathinfo(self):
r = parse( r = parse(
DEFAULT_ENV, DEFAULT_ENV,
extra={r'SCRIPT_NAME': r'/script', r'PATH_INFO': r'/pathinfo',}, extra={'SCRIPT_NAME': '/script', 'PATH_INFO': '/pathinfo',},
) )
self.assertEqual(r.url, b'http://testserver/script/pathinfo') self.assertEqual(r.url, b'http://testserver/script/pathinfo')
self.assertEqual(r.baseurl, b'http://testserver') self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl, b'http://testserver/script/pathinfo') self.assertEqual(r.advertisedurl, b'http://testserver/script/pathinfo')
self.assertEqual(r.advertisedbaseurl, b'http://testserver') self.assertEqual(r.advertisedbaseurl, b'http://testserver')
self.assertEqual(r.apppath, b'/script') self.assertEqual(r.apppath, b'/script')
self.assertEqual(r.dispatchparts, [b'pathinfo']) self.assertEqual(r.dispatchparts, [b'pathinfo'])
self.assertEqual(r.dispatchpath, b'pathinfo') self.assertEqual(r.dispatchpath, b'pathinfo')
r = parse( r = parse(
DEFAULT_ENV, DEFAULT_ENV,
extra={ extra={
r'SCRIPT_NAME': r'/script1/script2', 'SCRIPT_NAME': '/script1/script2',
r'PATH_INFO': r'/path1/path2', 'PATH_INFO': '/path1/path2',
}, },
) )
self.assertEqual( self.assertEqual(
r.url, b'http://testserver/script1/script2/path1/path2' r.url, b'http://testserver/script1/script2/path1/path2'
) )
self.assertEqual(r.baseurl, b'http://testserver') self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual( self.assertEqual(
r.advertisedurl, b'http://testserver/script1/script2/path1/path2' r.advertisedurl, b'http://testserver/script1/script2/path1/path2'
) )
self.assertEqual(r.advertisedbaseurl, b'http://testserver') self.assertEqual(r.advertisedbaseurl, b'http://testserver')
self.assertEqual(r.apppath, b'/script1/script2') self.assertEqual(r.apppath, b'/script1/script2')
self.assertEqual(r.dispatchparts, [b'path1', b'path2']) self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
self.assertEqual(r.dispatchpath, b'path1/path2') self.assertEqual(r.dispatchpath, b'path1/path2')
r = parse( r = parse(
DEFAULT_ENV, DEFAULT_ENV,
extra={ extra={
r'HTTP_HOST': r'hostserver', 'HTTP_HOST': 'hostserver',
r'SCRIPT_NAME': r'/script', 'SCRIPT_NAME': '/script',
r'PATH_INFO': r'/pathinfo', 'PATH_INFO': '/pathinfo',
}, },
) )
self.assertEqual(r.url, b'http://hostserver/script/pathinfo') self.assertEqual(r.url, b'http://hostserver/script/pathinfo')
self.assertEqual(r.baseurl, b'http://hostserver') self.assertEqual(r.baseurl, b'http://hostserver')
self.assertEqual(r.advertisedurl, b'http://testserver/script/pathinfo') self.assertEqual(r.advertisedurl, b'http://testserver/script/pathinfo')
self.assertEqual(r.advertisedbaseurl, b'http://testserver') self.assertEqual(r.advertisedbaseurl, b'http://testserver')
self.assertEqual(r.apppath, b'/script') self.assertEqual(r.apppath, b'/script')
parse(DEFAULT_ENV, reponame=b'repo') parse(DEFAULT_ENV, reponame=b'repo')
with self.assertRaisesRegex( with self.assertRaisesRegex(
error.ProgrammingError, 'PATH_INFO does not begin with repo ' 'name' error.ProgrammingError, 'PATH_INFO does not begin with repo ' 'name'
): ):
parse( parse(
DEFAULT_ENV, DEFAULT_ENV,
reponame=b'repo', reponame=b'repo',
extra={r'PATH_INFO': r'/pathinfo',}, extra={'PATH_INFO': '/pathinfo',},
) )
with self.assertRaisesRegex( with self.assertRaisesRegex(
error.ProgrammingError, 'reponame prefix of PATH_INFO' error.ProgrammingError, 'reponame prefix of PATH_INFO'
): ):
parse( parse(
DEFAULT_ENV, DEFAULT_ENV,
reponame=b'repo', reponame=b'repo',
extra={r'PATH_INFO': r'/repoextra/path',}, extra={'PATH_INFO': '/repoextra/path',},
) )
r = parse( r = parse(
DEFAULT_ENV, DEFAULT_ENV,
reponame=b'repo', reponame=b'repo',
extra={r'PATH_INFO': r'/repo/path1/path2',}, extra={'PATH_INFO': '/repo/path1/path2',},
) )
self.assertEqual(r.url, b'http://testserver/repo/path1/path2') self.assertEqual(r.url, b'http://testserver/repo/path1/path2')
self.assertEqual(r.baseurl, b'http://testserver') self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl, b'http://testserver/repo/path1/path2') self.assertEqual(r.advertisedurl, b'http://testserver/repo/path1/path2')
self.assertEqual(r.advertisedbaseurl, b'http://testserver') self.assertEqual(r.advertisedbaseurl, b'http://testserver')
self.assertEqual(r.apppath, b'/repo') self.assertEqual(r.apppath, b'/repo')
self.assertEqual(r.dispatchparts, [b'path1', b'path2']) self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
self.assertEqual(r.dispatchpath, b'path1/path2') self.assertEqual(r.dispatchpath, b'path1/path2')
self.assertEqual(r.reponame, b'repo') self.assertEqual(r.reponame, b'repo')
r = parse( r = parse(
DEFAULT_ENV, DEFAULT_ENV,
reponame=b'prefix/repo', reponame=b'prefix/repo',
extra={r'PATH_INFO': r'/prefix/repo/path1/path2',}, extra={'PATH_INFO': '/prefix/repo/path1/path2',},
) )
self.assertEqual(r.url, b'http://testserver/prefix/repo/path1/path2') self.assertEqual(r.url, b'http://testserver/prefix/repo/path1/path2')
self.assertEqual(r.baseurl, b'http://testserver') self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual( self.assertEqual(
r.advertisedurl, b'http://testserver/prefix/repo/path1/path2' r.advertisedurl, b'http://testserver/prefix/repo/path1/path2'
) )
self.assertEqual(r.advertisedbaseurl, b'http://testserver') self.assertEqual(r.advertisedbaseurl, b'http://testserver')
self.assertEqual(r.dispatchparts, []) self.assertEqual(r.dispatchparts, [])
self.assertIsNone(r.dispatchpath) self.assertIsNone(r.dispatchpath)
self.assertIsNone(r.reponame) self.assertIsNone(r.reponame)
# With only PATH_INFO defined. # With only PATH_INFO defined.
r = parse( r = parse(
DEFAULT_ENV, DEFAULT_ENV,
altbaseurl=b'http://altserver', altbaseurl=b'http://altserver',
extra={r'PATH_INFO': r'/path1/path2',}, extra={'PATH_INFO': '/path1/path2',},
) )
self.assertEqual(r.url, b'http://testserver/path1/path2') self.assertEqual(r.url, b'http://testserver/path1/path2')
self.assertEqual(r.baseurl, b'http://testserver') self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl, b'http://altserver/path1/path2') self.assertEqual(r.advertisedurl, b'http://altserver/path1/path2')
self.assertEqual(r.advertisedbaseurl, b'http://altserver') self.assertEqual(r.advertisedbaseurl, b'http://altserver')
self.assertEqual(r.urlscheme, b'http') self.assertEqual(r.urlscheme, b'http')
self.assertEqual(r.apppath, b'') self.assertEqual(r.apppath, b'')
self.assertEqual(r.dispatchparts, [b'path1', b'path2']) self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
self.assertEqual(r.dispatchparts, []) self.assertEqual(r.dispatchparts, [])
self.assertIsNone(r.dispatchpath) self.assertIsNone(r.dispatchpath)
self.assertIsNone(r.reponame) self.assertIsNone(r.reponame)
# PATH_INFO + path on alt URL. # PATH_INFO + path on alt URL.
r = parse( r = parse(
DEFAULT_ENV, DEFAULT_ENV,
altbaseurl=b'http://altserver/altpath', altbaseurl=b'http://altserver/altpath',
extra={r'PATH_INFO': r'/path1/path2',}, extra={'PATH_INFO': '/path1/path2',},
) )
self.assertEqual(r.url, b'http://testserver/path1/path2') self.assertEqual(r.url, b'http://testserver/path1/path2')
self.assertEqual(r.baseurl, b'http://testserver') self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual( self.assertEqual(
r.advertisedurl, b'http://altserver/altpath/path1/path2' r.advertisedurl, b'http://altserver/altpath/path1/path2'
) )
self.assertEqual(r.advertisedbaseurl, b'http://altserver') self.assertEqual(r.advertisedbaseurl, b'http://altserver')
self.assertEqual(r.urlscheme, b'http') self.assertEqual(r.urlscheme, b'http')
self.assertEqual(r.apppath, b'/altpath') self.assertEqual(r.apppath, b'/altpath')
self.assertEqual(r.dispatchparts, [b'path1', b'path2']) self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
self.assertEqual(r.dispatchpath, b'path1/path2') self.assertEqual(r.dispatchpath, b'path1/path2')
self.assertIsNone(r.reponame) self.assertIsNone(r.reponame)
# PATH_INFO + path on alt URL with trailing slash. # PATH_INFO + path on alt URL with trailing slash.
r = parse( r = parse(
DEFAULT_ENV, DEFAULT_ENV,
altbaseurl=b'http://altserver/altpath/', altbaseurl=b'http://altserver/altpath/',
extra={r'PATH_INFO': r'/path1/path2',}, extra={'PATH_INFO': '/path1/path2',},
) )
self.assertEqual(r.url, b'http://testserver/path1/path2') self.assertEqual(r.url, b'http://testserver/path1/path2')
self.assertEqual(r.baseurl, b'http://testserver') self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual( self.assertEqual(
r.advertisedurl, b'http://altserver/altpath//path1/path2' r.advertisedurl, b'http://altserver/altpath//path1/path2'
) )
self.assertEqual(r.advertisedbaseurl, b'http://altserver') self.assertEqual(r.advertisedbaseurl, b'http://altserver')
self.assertEqual(r.urlscheme, b'http') self.assertEqual(r.urlscheme, b'http')
self.assertEqual(r.apppath, b'/altpath/') self.assertEqual(r.apppath, b'/altpath/')
self.assertEqual(r.dispatchparts, [b'path1', b'path2']) self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
self.assertEqual(r.dispatchpath, b'path1/path2') self.assertEqual(r.dispatchpath, b'path1/path2')
self.assertIsNone(r.reponame) self.assertIsNone(r.reponame)
# Local SCRIPT_NAME is ignored. # Local SCRIPT_NAME is ignored.
r = parse( r = parse(
DEFAULT_ENV, DEFAULT_ENV,
altbaseurl=b'http://altserver', altbaseurl=b'http://altserver',
extra={r'SCRIPT_NAME': r'/script', r'PATH_INFO': r'/path1/path2',}, extra={'SCRIPT_NAME': '/script', 'PATH_INFO': '/path1/path2',},
) )
self.assertEqual(r.url, b'http://testserver/script/path1/path2') self.assertEqual(r.url, b'http://testserver/script/path1/path2')
self.assertEqual(r.baseurl, b'http://testserver') self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl, b'http://altserver/path1/path2') self.assertEqual(r.advertisedurl, b'http://altserver/path1/path2')
self.assertEqual(r.advertisedbaseurl, b'http://altserver') self.assertEqual(r.advertisedbaseurl, b'http://altserver')
self.assertEqual(r.urlscheme, b'http') self.assertEqual(r.urlscheme, b'http')
self.assertEqual(r.apppath, b'') self.assertEqual(r.apppath, b'')
self.assertEqual(r.dispatchparts, [b'path1', b'path2']) self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
self.assertEqual(r.dispatchpath, b'path1/path2') self.assertEqual(r.dispatchpath, b'path1/path2')
self.assertIsNone(r.reponame) self.assertIsNone(r.reponame)
# Use remote's path for script name, app path # Use remote's path for script name, app path
r = parse( r = parse(
DEFAULT_ENV, DEFAULT_ENV,
altbaseurl=b'http://altserver/altroot', altbaseurl=b'http://altserver/altroot',
extra={r'SCRIPT_NAME': r'/script', r'PATH_INFO': r'/path1/path2',}, extra={'SCRIPT_NAME': '/script', 'PATH_INFO': '/path1/path2',},
) )
self.assertEqual(r.url, b'http://testserver/script/path1/path2') self.assertEqual(r.url, b'http://testserver/script/path1/path2')
self.assertEqual(r.baseurl, b'http://testserver') self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual( self.assertEqual(
r.advertisedurl, b'http://altserver/altroot/path1/path2' r.advertisedurl, b'http://altserver/altroot/path1/path2'
) )
self.assertEqual(r.advertisedbaseurl, b'http://altserver') self.assertEqual(r.advertisedbaseurl, b'http://altserver')
self.assertEqual(r.urlscheme, b'http') self.assertEqual(r.urlscheme, b'http')
self.assertEqual(r.apppath, b'/altroot') self.assertEqual(r.apppath, b'/altroot')
self.assertEqual(r.dispatchparts, [b'path1', b'path2']) self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
self.assertEqual(r.dispatchpath, b'path1/path2') self.assertEqual(r.dispatchpath, b'path1/path2')
self.assertIsNone(r.reponame) self.assertIsNone(r.reponame)
# reponame is factored in properly. # reponame is factored in properly.
r = parse( r = parse(
DEFAULT_ENV, DEFAULT_ENV,
reponame=b'repo', reponame=b'repo',
altbaseurl=b'http://altserver/altroot', altbaseurl=b'http://altserver/altroot',
extra={ extra={'SCRIPT_NAME': '/script', 'PATH_INFO': '/repo/path1/path2',},
r'SCRIPT_NAME': r'/script',
r'PATH_INFO': r'/repo/path1/path2',
},
) )
self.assertEqual(r.url, b'http://testserver/script/repo/path1/path2') self.assertEqual(r.url, b'http://testserver/script/repo/path1/path2')
self.assertEqual(r.baseurl, b'http://testserver') self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual( self.assertEqual(
r.advertisedurl, b'http://altserver/altroot/repo/path1/path2' r.advertisedurl, b'http://altserver/altroot/repo/path1/path2'
) )
self.assertEqual(r.advertisedbaseurl, b'http://altserver') self.assertEqual(r.advertisedbaseurl, b'http://altserver')