This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7420

black: blacken scripts
ClosedPublic

Authored by indygreg on Nov 14 2019, 11:59 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG99e231afc29c: black: blacken scripts
Summary

test-check-format.t doesn't appear to detect Python scripts with shebangs.
But my editor which is configured to auto run black on Python files does
and it appears some files are not blackened.

This commit blackens scripts that need it.

  1. skip-blame reformatting

Diff Detail

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

Event Timeline

indygreg created this revision.Nov 14 2019, 11:59 PM
indygreg added a commit: rHG99e231afc29c: black: blacken scripts.Nov 15 2019, 12:11 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG99e231afc29c: black: blacken scripts (authored by indygreg). · Explain Why
This revision was automatically updated to reflect the committed changes.
marmoute added a subscriber: marmoute.Nov 15 2019, 6:52 AM

Can we update the test for catch theses too ?

Revision Contents
Changeset List

PathPackages
Mcontrib/check-commit (28 lines)
Mcontrib/dumprevlog (9 lines)
Mcontrib/hg-ssh (30 lines)
Mcontrib/hgperf (35 lines)
Mcontrib/hgweb.fcgi (9 lines)
Mcontrib/packaging/hg-docker (43 lines)
Mcontrib/relnotes (3 lines)
Mcontrib/simplemerge (59 lines)
Mcontrib/undumprevlog (13 lines)
Mhg (17 lines)

Diff 18151

contrib/check-commit

import sys import sys
commitheader = r"^(?:# [^\n]*\n)*" commitheader = r"^(?:# [^\n]*\n)*"
afterheader = commitheader + r"(?!#)" afterheader = commitheader + r"(?!#)"
beforepatch = afterheader + r"(?!\n(?!@@))" beforepatch = afterheader + r"(?!\n(?!@@))"
errors = [ errors = [
(beforepatch + r".*[(]bc[)]", "(BC) needs to be uppercase"), (beforepatch + r".*[(]bc[)]", "(BC) needs to be uppercase"),
(beforepatch + r".*[(]issue \d\d\d", (
"no space allowed between issue and number"), beforepatch + r".*[(]issue \d\d\d",
"no space allowed between issue and number",
),
(beforepatch + r".*[(]bug(\d|\s)", "use (issueDDDD) instead of bug"), (beforepatch + r".*[(]bug(\d|\s)", "use (issueDDDD) instead of bug"),
(commitheader + r"# User [^@\n]+\n", "username is not an email address"), (commitheader + r"# User [^@\n]+\n", "username is not an email address"),
(commitheader + r"(?!merge with )[^#]\S+[^:] ", (
"summary line doesn't start with 'topic: '"), commitheader + r"(?!merge with )[^#]\S+[^:] ",
"summary line doesn't start with 'topic: '",
),
(afterheader + r"[A-Z][a-z]\S+", "don't capitalize summary lines"), (afterheader + r"[A-Z][a-z]\S+", "don't capitalize summary lines"),
(afterheader + r"^\S+: *[A-Z][a-z]\S+", "don't capitalize summary lines"), (afterheader + r"^\S+: *[A-Z][a-z]\S+", "don't capitalize summary lines"),
(afterheader + r"\S*[^A-Za-z0-9-_]\S*: ", (
"summary keyword should be most user-relevant one-word command or topic"), afterheader + r"\S*[^A-Za-z0-9-_]\S*: ",
"summary keyword should be most user-relevant one-word command or topic",
),
(afterheader + r".*\.\s*\n", "don't add trailing period on summary line"), (afterheader + r".*\.\s*\n", "don't add trailing period on summary line"),
(afterheader + r".{79,}", "summary line too long (limit is 78)"), (afterheader + r".{79,}", "summary line too long (limit is 78)"),
] ]
word = re.compile(r'\S') word = re.compile(r'\S')
def nonempty(first, second): def nonempty(first, second):
if word.search(first): if word.search(first):
return first return first
return second return second
def checkcommit(commit, node=None): def checkcommit(commit, node=None):
exitcode = 0 exitcode = 0
printed = node is None printed = node is None
hits = [] hits = []
signtag = (afterheader + signtag = (
r'Added (tag [^ ]+|signature) for changeset [a-f0-9]{12}') afterheader + r'Added (tag [^ ]+|signature) for changeset [a-f0-9]{12}'
)
if re.search(signtag, commit): if re.search(signtag, commit):
return 0 return 0
for exp, msg in errors: for exp, msg in errors:
for m in re.finditer(exp, commit): for m in re.finditer(exp, commit):
end = m.end() end = m.end()
trailing = re.search(r'(\\n)+$', exp) trailing = re.search(r'(\\n)+$', exp)
if trailing: if trailing:
end -= len(trailing.group()) / 2 end -= len(trailing.group()) / 2
print(" %s" % nonempty(l, last)[:-1]) print(" %s" % nonempty(l, last)[:-1])
if "BYPASS" not in os.environ: if "BYPASS" not in os.environ:
exitcode = 1 exitcode = 1
del hits[0] del hits[0]
last = nonempty(l, last) last = nonempty(l, last)
return exitcode return exitcode
def readcommit(node): def readcommit(node):
return os.popen("hg export %s" % node).read() return os.popen("hg export %s" % node).read()
if __name__ == "__main__": if __name__ == "__main__":
exitcode = 0 exitcode = 0
node = os.environ.get("HG_NODE") node = os.environ.get("HG_NODE")
if node: if node:
commit = readcommit(node) commit = readcommit(node)
exitcode = checkcommit(commit) exitcode = checkcommit(commit)
elif sys.argv[1:]: elif sys.argv[1:]:
for node in sys.argv[1:]: for node in sys.argv[1:]:
exitcode |= checkcommit(readcommit(node), node) exitcode |= checkcommit(readcommit(node), node)
else: else:
commit = sys.stdin.read() commit = sys.stdin.read()
exitcode = checkcommit(commit) exitcode = checkcommit(commit)
sys.exit(exitcode) sys.exit(exitcode)

contrib/dumprevlog

#!/usr/bin/env python #!/usr/bin/env python
# Dump revlogs as raw data stream # Dump revlogs as raw data stream
# $ find .hg/store/ -name "*.i" | xargs dumprevlog > repo.dump # $ find .hg/store/ -name "*.i" | xargs dumprevlog > repo.dump
from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
import sys import sys
from mercurial import ( from mercurial import (
encoding, encoding,
node, node,
pycompat, pycompat,
revlog, revlog,
) )
from mercurial.utils import ( from mercurial.utils import procutil
procutil,
)
for fp in (sys.stdin, sys.stdout, sys.stderr): for fp in (sys.stdin, sys.stdout, sys.stderr):
procutil.setbinary(fp) procutil.setbinary(fp)
def binopen(path, mode=b'rb'): def binopen(path, mode=b'rb'):
if b'b' not in mode: if b'b' not in mode:
mode = mode + b'b' mode = mode + b'b'
return open(path, pycompat.sysstr(mode)) return open(path, pycompat.sysstr(mode))
binopen.options = {} binopen.options = {}
def printb(data, end=b'\n'): def printb(data, end=b'\n'):
sys.stdout.flush() sys.stdout.flush()
pycompat.stdout.write(data + end) pycompat.stdout.write(data + end)
for f in sys.argv[1:]: for f in sys.argv[1:]:
r = revlog.revlog(binopen, encoding.strtolocal(f)) r = revlog.revlog(binopen, encoding.strtolocal(f))
print("file:", f) print("file:", f)
for i in r: for i in r:
n = r.node(i) n = r.node(i)
p = r.parents(n) p = r.parents(n)
d = r.revision(n) d = r.revision(n)
printb(b"node: %s" % node.hex(n)) printb(b"node: %s" % node.hex(n))
printb(b"linkrev: %d" % r.linkrev(i)) printb(b"linkrev: %d" % r.linkrev(i))
printb(b"parents: %s %s" % (node.hex(p[0]), node.hex(p[1]))) printb(b"parents: %s %s" % (node.hex(p[0]), node.hex(p[1])))
printb(b"length: %d" % len(d)) printb(b"length: %d" % len(d))
printb(b"-start-") printb(b"-start-")
printb(d) printb(d)
printb(b"-end-") printb(b"-end-")

contrib/hg-ssh

""" """
from __future__ import absolute_import from __future__ import absolute_import
import os import os
import shlex import shlex
import sys import sys
# enable importing on demand to reduce startup time # enable importing on demand to reduce startup time
import hgdemandimport ; hgdemandimport.enable() import hgdemandimport
hgdemandimport.enable()
from mercurial import ( from mercurial import (
dispatch, dispatch,
pycompat, pycompat,
ui as uimod, ui as uimod,
) )
def main(): def main():
# Prevent insertion/deletion of CRs # Prevent insertion/deletion of CRs
dispatch.initstdio() dispatch.initstdio()
cwd = os.getcwd() cwd = os.getcwd()
readonly = False readonly = False
args = sys.argv[1:] args = sys.argv[1:]
while len(args): while len(args):
if args[0] == '--read-only': if args[0] == '--read-only':
readonly = True readonly = True
args.pop(0) args.pop(0)
else: else:
break break
allowed_paths = [os.path.normpath(os.path.join(cwd, allowed_paths = [
os.path.expanduser(path))) os.path.normpath(os.path.join(cwd, os.path.expanduser(path)))
for path in args] for path in args
]
orig_cmd = os.getenv('SSH_ORIGINAL_COMMAND', '?') orig_cmd = os.getenv('SSH_ORIGINAL_COMMAND', '?')
try: try:
cmdargv = shlex.split(orig_cmd) cmdargv = shlex.split(orig_cmd)
except ValueError as e: except ValueError as e:
sys.stderr.write('Illegal command "%s": %s\n' % (orig_cmd, e)) sys.stderr.write('Illegal command "%s": %s\n' % (orig_cmd, e))
sys.exit(255) sys.exit(255)
if cmdargv[:2] == ['hg', '-R'] and cmdargv[3:] == ['serve', '--stdio']: if cmdargv[:2] == ['hg', '-R'] and cmdargv[3:] == ['serve', '--stdio']:
path = cmdargv[2] path = cmdargv[2]
repo = os.path.normpath(os.path.join(cwd, os.path.expanduser(path))) repo = os.path.normpath(os.path.join(cwd, os.path.expanduser(path)))
if repo in allowed_paths: if repo in allowed_paths:
cmd = [b'-R', pycompat.fsencode(repo), b'serve', b'--stdio'] cmd = [b'-R', pycompat.fsencode(repo), b'serve', b'--stdio']
req = dispatch.request(cmd) req = dispatch.request(cmd)
if readonly: if readonly:
if not req.ui: if not req.ui:
req.ui = uimod.ui.load() req.ui = uimod.ui.load()
req.ui.setconfig(b'hooks', b'pretxnopen.hg-ssh', req.ui.setconfig(
b'python:__main__.rejectpush', b'hg-ssh') b'hooks',
req.ui.setconfig(b'hooks', b'prepushkey.hg-ssh', b'pretxnopen.hg-ssh',
b'python:__main__.rejectpush', b'hg-ssh') b'python:__main__.rejectpush',
b'hg-ssh',
)
req.ui.setconfig(
b'hooks',
b'prepushkey.hg-ssh',
b'python:__main__.rejectpush',
b'hg-ssh',
)
dispatch.dispatch(req) dispatch.dispatch(req)
else: else:
sys.stderr.write('Illegal repository "%s"\n' % repo) sys.stderr.write('Illegal repository "%s"\n' % repo)
sys.exit(255) sys.exit(255)
else: else:
sys.stderr.write('Illegal command "%s"\n' % orig_cmd) sys.stderr.write('Illegal command "%s"\n' % orig_cmd)
sys.exit(255) sys.exit(255)
def rejectpush(ui, **kwargs): def rejectpush(ui, **kwargs):
ui.warn((b"Permission denied\n")) ui.warn((b"Permission denied\n"))
# mercurial hooks use unix process conventions for hook return values # mercurial hooks use unix process conventions for hook return values
# so a truthy return means failure # so a truthy return means failure
return True return True
if __name__ == '__main__': if __name__ == '__main__':
main() main()

contrib/hgperf

import os import os
import sys import sys
libdir = '@LIBDIR@' libdir = '@LIBDIR@'
if libdir != '@' 'LIBDIR' '@': if libdir != '@' 'LIBDIR' '@':
if not os.path.isabs(libdir): if not os.path.isabs(libdir):
libdir = os.path.join(os.path.dirname(os.path.realpath(__file__)), libdir = os.path.join(
libdir) os.path.dirname(os.path.realpath(__file__)), libdir
)
libdir = os.path.abspath(libdir) libdir = os.path.abspath(libdir)
sys.path.insert(0, libdir) sys.path.insert(0, libdir)
# enable importing on demand to reduce startup time # enable importing on demand to reduce startup time
try: try:
from mercurial import demandimport; demandimport.enable() from mercurial import demandimport
demandimport.enable()
except ImportError: except ImportError:
import sys import sys
sys.stderr.write("abort: couldn't find mercurial libraries in [%s]\n" %
' '.join(sys.path)) sys.stderr.write(
"abort: couldn't find mercurial libraries in [%s]\n"
% ' '.join(sys.path)
)
sys.stderr.write("(check your install and PYTHONPATH)\n") sys.stderr.write("(check your install and PYTHONPATH)\n")
sys.exit(-1) sys.exit(-1)
from mercurial import ( from mercurial import (
dispatch, dispatch,
util, util,
) )
def timer(func, title=None): def timer(func, title=None):
results = [] results = []
begin = util.timer() begin = util.timer()
count = 0 count = 0
while True: while True:
ostart = os.times() ostart = os.times()
cstart = util.timer() cstart = util.timer()
r = func() r = func()
cstop = util.timer() cstop = util.timer()
ostop = os.times() ostop = os.times()
count += 1 count += 1
a, b = ostart, ostop a, b = ostart, ostop
results.append((cstop - cstart, b[0] - a[0], b[1]-a[1])) results.append((cstop - cstart, b[0] - a[0], b[1] - a[1]))
if cstop - begin > 3 and count >= 100: if cstop - begin > 3 and count >= 100:
break break
if cstop - begin > 10 and count >= 3: if cstop - begin > 10 and count >= 3:
break break
if title: if title:
sys.stderr.write("! %s\n" % title) sys.stderr.write("! %s\n" % title)
if r: if r:
sys.stderr.write("! result: %s\n" % r) sys.stderr.write("! result: %s\n" % r)
m = min(results) m = min(results)
sys.stderr.write("! wall %f comb %f user %f sys %f (best of %d)\n" sys.stderr.write(
% (m[0], m[1] + m[2], m[1], m[2], count)) "! wall %f comb %f user %f sys %f (best of %d)\n"
% (m[0], m[1] + m[2], m[1], m[2], count)
)
orgruncommand = dispatch.runcommand orgruncommand = dispatch.runcommand
def runcommand(lui, repo, cmd, fullargs, ui, options, d, cmdpats, cmdoptions): def runcommand(lui, repo, cmd, fullargs, ui, options, d, cmdpats, cmdoptions):
ui.pushbuffer() ui.pushbuffer()
lui.pushbuffer() lui.pushbuffer()
timer(lambda : orgruncommand(lui, repo, cmd, fullargs, ui, timer(
options, d, cmdpats, cmdoptions)) lambda: orgruncommand(
lui, repo, cmd, fullargs, ui, options, d, cmdpats, cmdoptions
)
)
ui.popbuffer() ui.popbuffer()
lui.popbuffer() lui.popbuffer()
dispatch.runcommand = runcommand dispatch.runcommand = runcommand
dispatch.run() dispatch.run()

contrib/hgweb.fcgi

#!/usr/bin/env python #!/usr/bin/env python
# #
# An example FastCGI script for use with flup, edit as necessary # An example FastCGI script for use with flup, edit as necessary
# Path to repo or hgweb config to serve (see 'hg help hgweb') # Path to repo or hgweb config to serve (see 'hg help hgweb')
config = "/path/to/repo/or/config" config = "/path/to/repo/or/config"
# Uncomment and adjust if Mercurial is not installed system-wide # Uncomment and adjust if Mercurial is not installed system-wide
# (consult "installed modules" path from 'hg debuginstall'): # (consult "installed modules" path from 'hg debuginstall'):
#import sys; sys.path.insert(0, "/path/to/python/lib") # import sys; sys.path.insert(0, "/path/to/python/lib")
# Uncomment to send python tracebacks to the browser if an error occurs: # Uncomment to send python tracebacks to the browser if an error occurs:
#import cgitb; cgitb.enable() # import cgitb; cgitb.enable()
from mercurial import demandimport; demandimport.enable() from mercurial import demandimport
demandimport.enable()
from mercurial.hgweb import hgweb from mercurial.hgweb import hgweb
from flup.server.fcgi import WSGIServer from flup.server.fcgi import WSGIServer
application = hgweb(config) application = hgweb(config)
WSGIServer(application).run() WSGIServer(application).run()

contrib/packaging/hg-docker

#!/usr/bin/env python3 #!/usr/bin/env python3
# #
# Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com> # Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
import argparse import argparse
import pathlib import pathlib
import shutil import shutil
import subprocess import subprocess
import sys import sys
def get_docker() -> str: def get_docker() -> str:
docker = shutil.which('docker.io') or shutil.which('docker') docker = shutil.which('docker.io') or shutil.which('docker')
if not docker: if not docker:
print('could not find docker executable') print('could not find docker executable')
return 1 return 1
try: try:
out = subprocess.check_output([docker, '-h'], stderr=subprocess.STDOUT) out = subprocess.check_output([docker, '-h'], stderr=subprocess.STDOUT)
if b'Jansens' in out: if b'Jansens' in out:
print('%s is the Docking System Tray; try installing docker.io' % print(
docker) '%s is the Docking System Tray; try installing docker.io'
% docker
)
sys.exit(1) sys.exit(1)
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
print('error calling `%s -h`: %s' % (docker, e.output)) print('error calling `%s -h`: %s' % (docker, e.output))
sys.exit(1) sys.exit(1)
out = subprocess.check_output([docker, 'version'], out = subprocess.check_output([docker, 'version'], stderr=subprocess.STDOUT)
stderr=subprocess.STDOUT)
lines = out.splitlines() lines = out.splitlines()
if not any(l.startswith((b'Client:', b'Client version:')) for l in lines): if not any(l.startswith((b'Client:', b'Client version:')) for l in lines):
print('`%s version` does not look like Docker' % docker) print('`%s version` does not look like Docker' % docker)
sys.exit(1) sys.exit(1)
if not any(l.startswith((b'Server:', b'Server version:')) for l in lines): if not any(l.startswith((b'Server:', b'Server version:')) for l in lines):
print('`%s version` does not look like Docker' % docker) print('`%s version` does not look like Docker' % docker)
sys.exit(1) sys.exit(1)
return docker return docker
def get_dockerfile(path: pathlib.Path, args: list) -> bytes: def get_dockerfile(path: pathlib.Path, args: list) -> bytes:
with path.open('rb') as fh: with path.open('rb') as fh:
df = fh.read() df = fh.read()
for k, v in args: for k, v in args:
df = df.replace(bytes('%%%s%%' % k.decode(), 'utf-8'), v) df = df.replace(bytes('%%%s%%' % k.decode(), 'utf-8'), v)
return df return df
def build_docker_image(dockerfile: pathlib.Path, params: list, tag: str): def build_docker_image(dockerfile: pathlib.Path, params: list, tag: str):
"""Build a Docker image from a templatized Dockerfile.""" """Build a Docker image from a templatized Dockerfile."""
docker = get_docker() docker = get_docker()
dockerfile_path = pathlib.Path(dockerfile) dockerfile_path = pathlib.Path(dockerfile)
dockerfile = get_dockerfile(dockerfile_path, params) dockerfile = get_dockerfile(dockerfile_path, params)
print('building Dockerfile:') print('building Dockerfile:')
print(dockerfile.decode('utf-8', 'replace')) print(dockerfile.decode('utf-8', 'replace'))
args = [ args = [
docker, docker,
'build', 'build',
'--build-arg', 'http_proxy', '--build-arg',
'--build-arg', 'https_proxy', 'http_proxy',
'--tag', tag, '--build-arg',
'https_proxy',
'--tag',
tag,
'-', '-',
] ]
print('executing: %r' % args) print('executing: %r' % args)
p = subprocess.Popen(args, stdin=subprocess.PIPE) p = subprocess.Popen(args, stdin=subprocess.PIPE)
p.communicate(input=dockerfile) p.communicate(input=dockerfile)
if p.returncode: if p.returncode:
raise subprocess.CalledProcessException( raise subprocess.CalledProcessException(
p.returncode, 'failed to build docker image: %s %s' p.returncode,
% (p.stdout, p.stderr)) 'failed to build docker image: %s %s' % (p.stdout, p.stderr),
)
def command_build(args): def command_build(args):
build_args = [] build_args = []
for arg in args.build_arg: for arg in args.build_arg:
k, v = arg.split('=', 1) k, v = arg.split('=', 1)
build_args.append((k.encode('utf-8'), v.encode('utf-8'))) build_args.append((k.encode('utf-8'), v.encode('utf-8')))
build_docker_image(pathlib.Path(args.dockerfile), build_docker_image(pathlib.Path(args.dockerfile), build_args, args.tag)
build_args,
args.tag)
def command_docker(args): def command_docker(args):
print(get_docker()) print(get_docker())
def main() -> int: def main() -> int:
parser = argparse.ArgumentParser() parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers(title='subcommands') subparsers = parser.add_subparsers(title='subcommands')
build = subparsers.add_parser('build', help='Build a Docker image') build = subparsers.add_parser('build', help='Build a Docker image')
build.set_defaults(func=command_build) build.set_defaults(func=command_build)
build.add_argument('--build-arg', action='append', default=[], build.add_argument(
help='Substitution to perform in Dockerfile; ' '--build-arg',
'format: key=value') action='append',
default=[],
help='Substitution to perform in Dockerfile; ' 'format: key=value',
)
build.add_argument('dockerfile', help='path to Dockerfile to use') build.add_argument('dockerfile', help='path to Dockerfile to use')
build.add_argument('tag', help='Tag to apply to created image') build.add_argument('tag', help='Tag to apply to created image')
docker = subparsers.add_parser('docker-path', help='Resolve path to Docker') docker = subparsers.add_parser('docker-path', help='Resolve path to Docker')
docker.set_defaults(func=command_docker) docker.set_defaults(func=command_docker)
args = parser.parse_args() args = parser.parse_args()
return args.func(args) return args.func(args)
if __name__ == '__main__': if __name__ == '__main__':
sys.exit(main()) sys.exit(main())

contrib/relnotes

(r"hgweb|paper|coal|gitweb|monoblue|spartan", "hgweb"), (r"hgweb|paper|coal|gitweb|monoblue|spartan", "hgweb"),
(r"pull|push|revert|resolve|annotate|bookmark|branch|clone", "commands"), (r"pull|push|revert|resolve|annotate|bookmark|branch|clone", "commands"),
(r"commands|commit|config|files|graft|import|log|merge|patch", "commands"), (r"commands|commit|config|files|graft|import|log|merge|patch", "commands"),
(r"phases|status|summary|amend|tag|help|verify", "commands"), (r"phases|status|summary|amend|tag|help|verify", "commands"),
(r"rebase|mq|convert|eol|histedit|largefiles", "extensions"), (r"rebase|mq|convert|eol|histedit|largefiles", "extensions"),
(r"shelve|unshelve", "extensions"), (r"shelve|unshelve", "extensions"),
] ]
def wikify(desc): def wikify(desc):
desc = desc.replace("(issue", "(Bts:issue") desc = desc.replace("(issue", "(Bts:issue")
desc = re.sub(r"\b([0-9a-f]{12})\b", r"Cset:\1", desc) desc = re.sub(r"\b([0-9a-f]{12})\b", r"Cset:\1", desc)
# stop ParseError from being recognized as a (nonexistent) wiki page # stop ParseError from being recognized as a (nonexistent) wiki page
desc = re.sub(r" ([A-Z][a-z]+[A-Z][a-z]+)\b", r" !\1", desc) desc = re.sub(r" ([A-Z][a-z]+[A-Z][a-z]+)\b", r" !\1", desc)
# prevent wiki markup of magic methods # prevent wiki markup of magic methods
desc = re.sub(r"\b(\S*__\S*)\b", r"`\1`", desc) desc = re.sub(r"\b(\S*__\S*)\b", r"`\1`", desc)
return desc return desc
def main(): def main():
desc = "example: %(prog)s 4.7.2 --stoprev 4.8rc0" desc = "example: %(prog)s 4.7.2 --stoprev 4.8rc0"
ap = argparse.ArgumentParser(description=desc) ap = argparse.ArgumentParser(description=desc)
ap.add_argument( ap.add_argument(
"startrev", "startrev",
metavar="REV", metavar="REV",
type=str, type=str,
help=( help=(
print(" * %s" % d) print(" * %s" % d)
if apis: if apis:
print("\n=== Internal API Changes ===\n") print("\n=== Internal API Changes ===\n")
for d in sorted(apis): for d in sorted(apis):
print(" * %s" % d) print(" * %s" % d)
if __name__ == "__main__": if __name__ == "__main__":
main() main()

contrib/simplemerge

#!/usr/bin/env python #!/usr/bin/env python
from __future__ import absolute_import from __future__ import absolute_import
import getopt import getopt
import sys import sys
import hgdemandimport import hgdemandimport
hgdemandimport.enable() hgdemandimport.enable()
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial import ( from mercurial import (
context, context,
error, error,
fancyopts, fancyopts,
pycompat, pycompat,
simplemerge, simplemerge,
ui as uimod, ui as uimod,
) )
from mercurial.utils import ( from mercurial.utils import procutil, stringutil
procutil,
stringutil
)
options = [(b'L', b'label', [], _(b'labels to use on conflict markers')), options = [
(b'L', b'label', [], _(b'labels to use on conflict markers')),
(b'a', b'text', None, _(b'treat all files as text')), (b'a', b'text', None, _(b'treat all files as text')),
(b'p', b'print', None, (b'p', b'print', None, _(b'print results instead of overwriting LOCAL')),
_(b'print results instead of overwriting LOCAL')),
(b'', b'no-minimal', None, _(b'no effect (DEPRECATED)')), (b'', b'no-minimal', None, _(b'no effect (DEPRECATED)')),
(b'h', b'help', None, _(b'display help and exit')), (b'h', b'help', None, _(b'display help and exit')),
(b'q', b'quiet', None, _(b'suppress output'))] (b'q', b'quiet', None, _(b'suppress output')),
]
usage = _(b'''simplemerge [OPTS] LOCAL BASE OTHER usage = _(
b'''simplemerge [OPTS] LOCAL BASE OTHER
Simple three-way file merge utility with a minimal feature set. Simple three-way file merge utility with a minimal feature set.
Apply to LOCAL the changes necessary to go from BASE to OTHER. Apply to LOCAL the changes necessary to go from BASE to OTHER.
By default, LOCAL is overwritten with the results of this operation. By default, LOCAL is overwritten with the results of this operation.
''') '''
)
class ParseError(Exception): class ParseError(Exception):
"""Exception raised on errors in parsing the command line.""" """Exception raised on errors in parsing the command line."""
def showhelp(): def showhelp():
pycompat.stdout.write(usage) pycompat.stdout.write(usage)
pycompat.stdout.write(b'\noptions:\n') pycompat.stdout.write(b'\noptions:\n')
out_opts = [] out_opts = []
for shortopt, longopt, default, desc in options: for shortopt, longopt, default, desc in options:
out_opts.append((b'%2s%s' % (shortopt and b'-%s' % shortopt, out_opts.append(
longopt and b' --%s' % longopt), (
b'%s' % desc)) b'%2s%s'
% (
shortopt and b'-%s' % shortopt,
longopt and b' --%s' % longopt,
),
b'%s' % desc,
)
)
opts_len = max([len(opt[0]) for opt in out_opts]) opts_len = max([len(opt[0]) for opt in out_opts])
for first, second in out_opts: for first, second in out_opts:
pycompat.stdout.write(b' %-*s %s\n' % (opts_len, first, second)) pycompat.stdout.write(b' %-*s %s\n' % (opts_len, first, second))
try: try:
for fp in (sys.stdin, pycompat.stdout, sys.stderr): for fp in (sys.stdin, pycompat.stdout, sys.stderr):
procutil.setbinary(fp) procutil.setbinary(fp)
opts = {} opts = {}
try: try:
bargv = [a.encode('utf8') for a in sys.argv[1:]] bargv = [a.encode('utf8') for a in sys.argv[1:]]
args = fancyopts.fancyopts(bargv, options, opts) args = fancyopts.fancyopts(bargv, options, opts)
except getopt.GetoptError as e: except getopt.GetoptError as e:
raise ParseError(e) raise ParseError(e)
if opts[b'help']: if opts[b'help']:
showhelp() showhelp()
sys.exit(0) sys.exit(0)
if len(args) != 3: if len(args) != 3:
raise ParseError(_(b'wrong number of arguments').decode('utf8')) raise ParseError(_(b'wrong number of arguments').decode('utf8'))
local, base, other = args local, base, other = args
sys.exit(simplemerge.simplemerge(uimod.ui.load(), sys.exit(
simplemerge.simplemerge(
uimod.ui.load(),
context.arbitraryfilectx(local), context.arbitraryfilectx(local),
context.arbitraryfilectx(base), context.arbitraryfilectx(base),
context.arbitraryfilectx(other), context.arbitraryfilectx(other),
**pycompat.strkwargs(opts))) **pycompat.strkwargs(opts)
)
)
except ParseError as e: except ParseError as e:
e = stringutil.forcebytestr(e) e = stringutil.forcebytestr(e)
pycompat.stdout.write(b"%s: %s\n" % (sys.argv[0].encode('utf8'), e)) pycompat.stdout.write(b"%s: %s\n" % (sys.argv[0].encode('utf8'), e))
showhelp() showhelp()
sys.exit(1) sys.exit(1)
except error.Abort as e: except error.Abort as e:
pycompat.stderr.write(b"abort: %s\n" % e) pycompat.stderr.write(b"abort: %s\n" % e)
sys.exit(255) sys.exit(255)
except KeyboardInterrupt: except KeyboardInterrupt:
sys.exit(255) sys.exit(255)

contrib/undumprevlog

#!/usr/bin/env python #!/usr/bin/env python
# Undump a dump from dumprevlog # Undump a dump from dumprevlog
# $ hg init # $ hg init
# $ undumprevlog < repo.dump # $ undumprevlog < repo.dump
from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
import sys import sys
from mercurial import ( from mercurial import (
encoding, encoding,
node, node,
pycompat, pycompat,
revlog, revlog,
transaction, transaction,
vfs as vfsmod, vfs as vfsmod,
) )
from mercurial.utils import ( from mercurial.utils import procutil
procutil,
)
for fp in (sys.stdin, sys.stdout, sys.stderr): for fp in (sys.stdin, sys.stdout, sys.stderr):
procutil.setbinary(fp) procutil.setbinary(fp)
opener = vfsmod.vfs(b'.', False) opener = vfsmod.vfs(b'.', False)
tr = transaction.transaction(sys.stderr.write, opener, {b'store': opener}, tr = transaction.transaction(
b"undump.journal") sys.stderr.write, opener, {b'store': opener}, b"undump.journal"
)
while True: while True:
l = sys.stdin.readline() l = sys.stdin.readline()
if not l: if not l:
break break
if l.startswith("file:"): if l.startswith("file:"):
f = encoding.strtolocal(l[6:-1]) f = encoding.strtolocal(l[6:-1])
r = revlog.revlog(opener, f) r = revlog.revlog(opener, f)
pycompat.stdout.write(b'%s\n' % f) pycompat.stdout.write(b'%s\n' % f)
elif l.startswith("node:"): elif l.startswith("node:"):
n = node.bin(l[6:-1]) n = node.bin(l[6:-1])
elif l.startswith("linkrev:"): elif l.startswith("linkrev:"):
lr = int(l[9:-1]) lr = int(l[9:-1])
elif l.startswith("parents:"): elif l.startswith("parents:"):
p = l[9:-1].split() p = l[9:-1].split()
p1 = node.bin(p[0]) p1 = node.bin(p[0])
p2 = node.bin(p[1]) p2 = node.bin(p[1])
elif l.startswith("length:"): elif l.startswith("length:"):
length = int(l[8:-1]) length = int(l[8:-1])
sys.stdin.readline() # start marker sys.stdin.readline() # start marker
d = encoding.strtolocal(sys.stdin.read(length)) d = encoding.strtolocal(sys.stdin.read(length))
sys.stdin.readline() # end marker sys.stdin.readline() # end marker
r.addrevision(d, tr, lr, p1, p2) r.addrevision(d, tr, lr, p1, p2)
tr.close() tr.close()

hg

import os import os
import sys import sys
libdir = '@LIBDIR@' libdir = '@LIBDIR@'
if libdir != '@' 'LIBDIR' '@': if libdir != '@' 'LIBDIR' '@':
if not os.path.isabs(libdir): if not os.path.isabs(libdir):
libdir = os.path.join(os.path.dirname(os.path.realpath(__file__)), libdir = os.path.join(
libdir) os.path.dirname(os.path.realpath(__file__)), libdir
)
libdir = os.path.abspath(libdir) libdir = os.path.abspath(libdir)
sys.path.insert(0, libdir) sys.path.insert(0, libdir)
from hgdemandimport import tracing from hgdemandimport import tracing
with tracing.log('hg script'): with tracing.log('hg script'):
# enable importing on demand to reduce startup time # enable importing on demand to reduce startup time
try: try:
if sys.version_info[0] < 3 or sys.version_info >= (3, 6): if sys.version_info[0] < 3 or sys.version_info >= (3, 6):
import hgdemandimport; hgdemandimport.enable() import hgdemandimport
hgdemandimport.enable()
except ImportError: except ImportError:
sys.stderr.write("abort: couldn't find mercurial libraries in [%s]\n" % sys.stderr.write(
' '.join(sys.path)) "abort: couldn't find mercurial libraries in [%s]\n"
% ' '.join(sys.path)
)
sys.stderr.write("(check your install and PYTHONPATH)\n") sys.stderr.write("(check your install and PYTHONPATH)\n")
sys.exit(-1) sys.exit(-1)
from mercurial import dispatch from mercurial import dispatch
dispatch.run() dispatch.run()