This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5539

style: run yapf on a subset of mercurial
Needs RevisionPublic

Authored by durin42 on Jan 9 2019, 3:28 PM.

Details

Reviewers
baymax
Group Reviewers
hg-reviewers
Summary

I've tried to pick knobs that more or less conform to our current
style. I ran the formatter on the same set of files as the black
proposal (see D5064), but it resulted in many fewer edits.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

durin42 created this revision.Jan 9 2019, 3:28 PM
durin42 added a comment.Jan 9 2019, 3:36 PM

I see a few minor issues here, but it's at least plausible?

mercurial/minifileset.py
57–58

yapf bug here, filed as https://github.com/google/yapf/issues/662

mercurial/scmwindows.py
53

We could force this to one-per-line by adding a trailing comma.

baymax requested changes to this revision.Jan 24 2020, 12:32 PM

There seems to have been no activities on this Diff for the past 3 Months.

By policy, we are automatically moving it out of the need-review state.

Please, move it back to need-review without hesitation if this diff should still be discussed.

:baymax:need-review-idle:

This revision now requires changes to proceed.Jan 24 2020, 12:32 PM

Revision Contents
Changeset List

Diff 13110

.style.yapf

  • This file was added.
[style]
based_on_style = pep8
blank_lines_around_top_level_definition = 1
spaces_before_comment = 1
column_limit = 80
split_all_comma_separated_values = true
space_between_ending_comma_and_closing_bracket = false
allow_multiline_lambdas = true

mercurial/dirstateguard.py

This just removes the backup file at ``close()`` before ``release()``. This just removes the backup file at ``close()`` before ``release()``.
''' '''
def __init__(self, repo, name): def __init__(self, repo, name):
self._repo = repo self._repo = repo
self._active = False self._active = False
self._closed = False self._closed = False
self._backupname = 'dirstate.backup.%s.%d' % (name, id(self)) self._backupname = 'dirstate.backup.%s.%d' % (name, id(self))
self._narrowspecbackupname = ('narrowspec.backup.%s.%d' % self._narrowspecbackupname = ('narrowspec.backup.%s.%d' % (name,
(name, id(self))) id(self)))
repo.dirstate.savebackup(repo.currenttransaction(), self._backupname) repo.dirstate.savebackup(repo.currenttransaction(), self._backupname)
narrowspec.savebackup(repo, self._narrowspecbackupname) narrowspec.savebackup(repo, self._narrowspecbackupname)
self._active = True self._active = True
def __del__(self): def __del__(self):
if self._active: # still active if self._active: # still active
# this may occur, even if this class is used correctly: # this may occur, even if this class is used correctly:
# for example, releasing other resources like transaction # for example, releasing other resources like transaction
# may raise exception before ``dirstateguard.release`` in # may raise exception before ``dirstateguard.release`` in
# ``release(tr, ....)``. # ``release(tr, ....)``.
self._abort() self._abort()
def close(self): def close(self):
if not self._active: # already inactivated if not self._active: # already inactivated
msg = (_("can't close already inactivated backup: %s") msg = (_("can't close already inactivated backup: %s") %
% self._backupname) self._backupname)
raise error.Abort(msg) raise error.Abort(msg)
self._repo.dirstate.clearbackup(self._repo.currenttransaction(), self._repo.dirstate.clearbackup(self._repo.currenttransaction(),
self._backupname) self._backupname)
narrowspec.clearbackup(self._repo, self._narrowspecbackupname) narrowspec.clearbackup(self._repo, self._narrowspecbackupname)
self._active = False self._active = False
self._closed = True self._closed = True
def _abort(self): def _abort(self):
narrowspec.restorebackup(self._repo, self._narrowspecbackupname) narrowspec.restorebackup(self._repo, self._narrowspecbackupname)
self._repo.dirstate.restorebackup(self._repo.currenttransaction(), self._repo.dirstate.restorebackup(self._repo.currenttransaction(),
self._backupname) self._backupname)
self._active = False self._active = False
def release(self): def release(self):
if not self._closed: if not self._closed:
if not self._active: # already inactivated if not self._active: # already inactivated
msg = (_("can't release already inactivated backup: %s") msg = (_("can't release already inactivated backup: %s") %
% self._backupname) self._backupname)
raise error.Abort(msg) raise error.Abort(msg)
self._abort() self._abort()

mercurial/httpconnection.py

self.write = self._data.write self.write = self._data.write
self.length = os.fstat(self._data.fileno()).st_size self.length = os.fstat(self._data.fileno()).st_size
self._pos = 0 self._pos = 0
# We pass double the max for total because we currently have # We pass double the max for total because we currently have
# to send the bundle twice in the case of a server that # to send the bundle twice in the case of a server that
# requires authentication. Since we can't know until we try # requires authentication. Since we can't know until we try
# once whether authentication will be required, just lie to # once whether authentication will be required, just lie to
# the user and maybe the push succeeds suddenly at 50%. # the user and maybe the push succeeds suddenly at 50%.
self._progress = ui.makeprogress(_('sending'), unit=_('kb'), self._progress = ui.makeprogress(
_('sending'),
unit=_('kb'),
total=(self.length // 1024 * 2)) total=(self.length // 1024 * 2))
def read(self, *args, **kwargs): def read(self, *args, **kwargs):
ret = self._data.read(*args, **kwargs) ret = self._data.read(*args, **kwargs)
if not ret: if not ret:
self._progress.complete() self._progress.complete()
return ret return ret
self._pos += len(ret) self._pos += len(ret)
self._progress.update(self._pos // 1024) self._progress.update(self._pos // 1024)

mercurial/lsprofcalltree.py

out_file = self.out_file out_file = self.out_file
code = subentry.code code = subentry.code
out_file.write(b'cfn=%s\n' % label(code)) out_file.write(b'cfn=%s\n' % label(code))
if isinstance(code, str): if isinstance(code, str):
out_file.write(b'cfi=~\n') out_file.write(b'cfi=~\n')
out_file.write(b'calls=%d 0\n' % subentry.callcount) out_file.write(b'calls=%d 0\n' % subentry.callcount)
else: else:
out_file.write(b'cfi=%s\n' % pycompat.sysbytes(code.co_filename)) out_file.write(b'cfi=%s\n' % pycompat.sysbytes(code.co_filename))
out_file.write(b'calls=%d %d\n' % ( out_file.write(b'calls=%d %d\n' % (subentry.callcount,
subentry.callcount, code.co_firstlineno)) code.co_firstlineno))
totaltime = int(subentry.totaltime * 1000) totaltime = int(subentry.totaltime * 1000)
out_file.write(b'%d %d\n' % (lineno, totaltime)) out_file.write(b'%d %d\n' % (lineno, totaltime))

mercurial/mergeutil.py

from .i18n import _ from .i18n import _
from . import ( from . import (
error, error,
) )
def checkunresolved(ms): def checkunresolved(ms):
if list(ms.unresolved()): if list(ms.unresolved()):
raise error.Abort(_("unresolved merge conflicts " raise error.Abort(
_("unresolved merge conflicts "
"(see 'hg help resolve')")) "(see 'hg help resolve')"))
if ms.mdstate() != 's' or list(ms.driverresolved()): if ms.mdstate() != 's' or list(ms.driverresolved()):
raise error.Abort(_('driver-resolved merge conflicts'), raise error.Abort(
_('driver-resolved merge conflicts'),
hint=_('run "hg resolve --all" to resolve')) hint=_('run "hg resolve --all" to resolve'))

mercurial/minifileset.py

raise error.ParseError(_('reserved character: %s') % c) raise error.ParseError(_('reserved character: %s') % c)
return lambda n, s: n.endswith(ext) return lambda n, s: n.endswith(ext)
elif name.startswith('path:'): # directory or full path test elif name.startswith('path:'): # directory or full path test
p = name[5:] # prefix p = name[5:] # prefix
pl = len(p) pl = len(p)
f = lambda n, s: n.startswith(p) and (len(n) == pl f = lambda n, s: n.startswith(p) and (len(n) == pl
or n[pl:pl + 1] == '/') or n[pl:pl + 1] == '/')
return f return f
raise error.ParseError(_("unsupported file pattern: %s") % name, raise error.ParseError(
_("unsupported file pattern: %s") % name,
hint=_('paths must be prefixed with "path:"')) hint=_('paths must be prefixed with "path:"'))
elif op in {'or', 'patterns'}: elif op in {'or', 'patterns'}:
funcs = [_compile(x) for x in tree[1:]] funcs = [_compile(x) for x in tree[1:]]
return lambda n, s: any(f(n, s) for f in funcs) return lambda n, s: any(f(n, s) for f in funcs)
elif op == 'and': elif op == 'and':
func1 = _compile(tree[1]) func1 = _compile(tree[1])
func2 = _compile(tree[2]) func2 = _compile(tree[2])
return lambda n, s: func1(n, s) and func2(n, s) return lambda n, s: func1(n, s) and func2(n, s)
elif op == 'not': elif op == 'not':
return lambda n, s: not _compile(tree[1])(n, s) return lambda n, s: not _compile(tree[1])(n, s)
elif op == 'func': elif op == 'func':
symbols = { symbols = {
'all': lambda n, s: True, 'all': lambda n,
'none': lambda n, s: False, s: True,
durin42AuthorUnsubmitted
Not Done

yapf bug here, filed as https://github.com/google/yapf/issues/662

durin42: yapf bug here, filed as https://github.com/google/yapf/issues/662
'size': lambda n, s: _sizep(tree[2])(s), 'none': lambda n,
s: False,
'size': lambda n,
s: _sizep(tree[2])(s),
} }
name = filesetlang.getsymbol(tree[1]) name = filesetlang.getsymbol(tree[1])
if name in symbols: if name in symbols:
return symbols[name] return symbols[name]
raise error.UnknownIdentifier(name, symbols.keys()) raise error.UnknownIdentifier(name, symbols.keys())
elif op == 'minus': # equivalent to 'x and not y' elif op == 'minus': # equivalent to 'x and not y'
func1 = _compile(tree[1]) func1 = _compile(tree[1])
func2 = _compile(tree[2]) func2 = _compile(tree[2])
return lambda n, s: func1(n, s) and not func2(n, s) return lambda n, s: func1(n, s) and not func2(n, s)
elif op == 'list': elif op == 'list':
raise error.ParseError(_("can't use a list in this context"), raise error.ParseError(
_("can't use a list in this context"),
hint=_('see \'hg help "filesets.x or y"\'')) hint=_('see \'hg help "filesets.x or y"\''))
raise error.ProgrammingError('illegal tree: %r' % (tree,)) raise error.ProgrammingError('illegal tree: %r' % (tree,))
def compile(text): def compile(text):
"""generate a function (path, size) -> bool from filter specification. """generate a function (path, size) -> bool from filter specification.
"text" could contain the operators defined by the fileset language for "text" could contain the operators defined by the fileset language for
common logic operations, and parenthesis for grouping. The supported path common logic operations, and parenthesis for grouping. The supported path
tests are '**.extname' for file extension test, and '"path:dir/subdir"' tests are '**.extname' for file extension test, and '"path:dir/subdir"'

mercurial/node.py

# node.py - basic nodeid manipulation for mercurial # node.py - basic nodeid manipulation for mercurial
# #
# Copyright 2005, 2006 Matt Mackall <mpm@selenic.com> # Copyright 2005, 2006 Matt Mackall <mpm@selenic.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.
from __future__ import absolute_import from __future__ import absolute_import
import binascii import binascii
# This ugly style has a noticeable effect in manifest parsing # This ugly style has a noticeable effect in manifest parsing
hex = binascii.hexlify hex = binascii.hexlify
# Adapt to Python 3 API changes. If this ends up showing up in # Adapt to Python 3 API changes. If this ends up showing up in
# profiles, we can use this version only on Python 3, and forward # profiles, we can use this version only on Python 3, and forward
# binascii.unhexlify like we used to on Python 2. # binascii.unhexlify like we used to on Python 2.
def bin(s): def bin(s):
try: try:
return binascii.unhexlify(s) return binascii.unhexlify(s)
except binascii.Error as e: except binascii.Error as e:
raise TypeError(e) raise TypeError(e)

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': (r'cext',
b'allow': (r'cext', r'pure'), None),
b'cffi': (r'cffi', None), b'allow': (r'cext',
b'cffi-allow': (r'cffi', r'pure'), r'pure'),
b'py': (None, r'pure'), b'cffi': (r'cffi',
None),
b'cffi-allow': (r'cffi',
r'pure'),
b'py': (None,
r'pure'),
} }
try: try:
from . import __modulepolicy__ from . import __modulepolicy__
policy = __modulepolicy__.modulepolicy policy = __modulepolicy__.modulepolicy
except ImportError: except ImportError:
pass pass
except AttributeError: except AttributeError:
raise ImportError(r'cannot import name %s' % modname) raise ImportError(r'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, r'__doc__', None) getattr(mod, r'__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, (r'cext',
(r'cext', r'bdiff'): 3, r'base85'): 1,
(r'cext', r'mpatch'): 1, (r'cext',
(r'cext', r'osutil'): 4, r'bdiff'): 3,
(r'cext', r'parsers'): 12, (r'cext',
r'mpatch'): 1,
(r'cext',
r'osutil'): 4,
(r'cext',
r'parsers'): 12,
} }
# 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'), (r'cext',
(r'cffi', r'base85'): (r'pure', r'base85'), r'charencode'): (r'cext',
(r'cffi', r'charencode'): (r'pure', r'charencode'), r'parsers'),
(r'cffi', r'parsers'): (r'pure', r'parsers'), (r'cffi',
r'base85'): (r'pure',
r'base85'),
(r'cffi',
r'charencode'): (r'pure',
r'charencode'),
(r'cffi',
r'parsers'): (r'pure',
r'parsers'),
} }
def _checkmod(pkgname, modname, mod): def _checkmod(pkgname, modname, mod):
expected = _cextversions.get((pkgname, modname)) expected = _cextversions.get((pkgname, modname))
actual = getattr(mod, r'version', None) actual = getattr(mod, r'version', None)
if actual != expected: if actual != expected:
raise ImportError(r'cannot import module %s.%s ' raise ImportError(r'cannot import module %s.%s '
r'(expected version: %d, actual: %r)' r'(expected version: %d, actual: %r)' % (pkgname,
% (pkgname, modname, expected, actual)) 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(r'invalid HGMODULEPOLICY %r' % policy)
assert verpkg or purepkg assert verpkg or purepkg

mercurial/pushkey.py

def _nslist(repo): def _nslist(repo):
n = {} n = {}
for k in _namespaces: for k in _namespaces:
n[k] = "" n[k] = ""
if not obsolete.isenabled(repo, obsolete.exchangeopt): if not obsolete.isenabled(repo, obsolete.exchangeopt):
n.pop('obsolete') n.pop('obsolete')
return n return n
_namespaces = {"namespaces": (lambda *x: False, _nslist), _namespaces = {
"bookmarks": (bookmarks.pushbookmark, bookmarks.listbookmarks), "namespaces": (lambda *x: False,
"phases": (phases.pushphase, phases.listphases), _nslist),
"obsolete": (obsolete.pushmarker, obsolete.listmarkers), "bookmarks": (bookmarks.pushbookmark,
bookmarks.listbookmarks),
"phases": (phases.pushphase,
phases.listphases),
"obsolete": (obsolete.pushmarker,
obsolete.listmarkers),
} }
def register(namespace, pushkey, listkeys): def register(namespace, pushkey, listkeys):
_namespaces[namespace] = (pushkey, listkeys) _namespaces[namespace] = (pushkey, listkeys)
def _get(namespace): def _get(namespace):
return _namespaces.get(namespace, (lambda *x: False, lambda *x: {})) return _namespaces.get(namespace, (lambda *x: False, lambda *x: {}))
def push(repo, namespace, key, old, new): def push(repo, namespace, key, old, new):

mercurial/rcutil.py

The config items are extracted from environment variables specified by env, The config items are extracted from environment variables specified by env,
used to override systemrc, but not userrc. used to override systemrc, but not userrc.
If env is not provided, encoding.environ will be used. If env is not provided, encoding.environ will be used.
''' '''
if env is None: if env is None:
env = encoding.environ env = encoding.environ
checklist = [ checklist = [
('EDITOR', 'ui', 'editor'), ('EDITOR',
('VISUAL', 'ui', 'editor'), 'ui',
('PAGER', 'pager', 'pager'), 'editor'),
('VISUAL',
'ui',
'editor'),
('PAGER',
'pager',
'pager'),
] ]
result = [] result = []
for envname, section, configname in checklist: for envname, section, configname in checklist:
if envname not in env: if envname not in env:
continue continue
result.append((section, configname, env[envname], '$%s' % envname)) result.append((section, configname, env[envname], '$%s' % envname))
return result return result

mercurial/scmposix.py

# OS X is widely used and most modern Unix systems would have 'less', setting # OS X is widely used and most modern Unix systems would have 'less', setting
# 'less' as the default seems reasonable. # 'less' as the default seems reasonable.
fallbackpager = 'less' fallbackpager = 'less'
def _rcfiles(path): def _rcfiles(path):
rcs = [os.path.join(path, 'hgrc')] rcs = [os.path.join(path, 'hgrc')]
rcdir = os.path.join(path, 'hgrc.d') rcdir = os.path.join(path, 'hgrc.d')
try: try:
rcs.extend([os.path.join(rcdir, f) rcs.extend([
for f, kind in util.listdir(rcdir) os.path.join(rcdir,
if f.endswith(".rc")]) f) for f,
kind in util.listdir(rcdir) if f.endswith(".rc")
])
except OSError: except OSError:
pass pass
return rcs return rcs
def systemrcpath(): def systemrcpath():
path = [] path = []
if pycompat.sysplatform == 'plan9': if pycompat.sysplatform == 'plan9':
root = 'lib/mercurial' root = 'lib/mercurial'
return [encoding.environ['home'] + '/lib/hgrc'] return [encoding.environ['home'] + '/lib/hgrc']
elif pycompat.isdarwin: elif pycompat.isdarwin:
return [os.path.expanduser('~/.hgrc')] return [os.path.expanduser('~/.hgrc')]
else: else:
confighome = encoding.environ.get('XDG_CONFIG_HOME') confighome = encoding.environ.get('XDG_CONFIG_HOME')
if confighome is None or not os.path.isabs(confighome): if confighome is None or not os.path.isabs(confighome):
confighome = os.path.expanduser('~/.config') confighome = os.path.expanduser('~/.config')
return [os.path.expanduser('~/.hgrc'), return [
os.path.join(confighome, 'hg', 'hgrc')] os.path.expanduser('~/.hgrc'),
os.path.join(confighome,
'hg',
'hgrc')
]
def termsize(ui): def termsize(ui):
try: try:
import termios import termios
TIOCGWINSZ = termios.TIOCGWINSZ # unavailable on IRIX (issue3449) TIOCGWINSZ = termios.TIOCGWINSZ # unavailable on IRIX (issue3449)
except (AttributeError, ImportError): except (AttributeError, ImportError):
return 80, 24 return 80, 24
for dev in (ui.ferr, ui.fout, ui.fin): for dev in (ui.ferr, ui.fout, ui.fin):
try: try:
try: try:
fd = dev.fileno() fd = dev.fileno()
except AttributeError: except AttributeError:

mercurial/scmwindows.py

rcpath.append(progrc) rcpath.append(progrc)
# Use hgrc.d found in directory with hg.exe # Use hgrc.d found in directory with hg.exe
progrcd = os.path.join(os.path.dirname(filename), 'hgrc.d') progrcd = os.path.join(os.path.dirname(filename), 'hgrc.d')
if os.path.isdir(progrcd): if os.path.isdir(progrcd):
for f, kind in util.listdir(progrcd): for f, kind in util.listdir(progrcd):
if f.endswith('.rc'): if f.endswith('.rc'):
rcpath.append(os.path.join(progrcd, f)) rcpath.append(os.path.join(progrcd, f))
# else look for a system rcpath in the registry # else look for a system rcpath in the registry
value = util.lookupreg('SOFTWARE\\Mercurial', None, value = util.lookupreg('SOFTWARE\\Mercurial',
None,
winreg.HKEY_LOCAL_MACHINE) winreg.HKEY_LOCAL_MACHINE)
if not isinstance(value, str) or not value: if not isinstance(value, str) or not value:
return rcpath return rcpath
value = util.localpath(value) value = util.localpath(value)
for p in value.split(pycompat.ospathsep): for p in value.split(pycompat.ospathsep):
if p.lower().endswith('mercurial.ini'): if p.lower().endswith('mercurial.ini'):
rcpath.append(p) rcpath.append(p)
elif os.path.isdir(p): elif os.path.isdir(p):
for f, kind in util.listdir(p): for f, kind in util.listdir(p):
if f.endswith('.rc'): if f.endswith('.rc'):
rcpath.append(os.path.join(p, f)) rcpath.append(os.path.join(p, f))
return rcpath return rcpath
def userrcpath(): def userrcpath():
'''return os-specific hgrc search path to the user dir''' '''return os-specific hgrc search path to the user dir'''
home = os.path.expanduser('~') home = os.path.expanduser('~')
path = [os.path.join(home, 'mercurial.ini'), path = [os.path.join(home, 'mercurial.ini'), os.path.join(home, '.hgrc')]
durin42AuthorUnsubmitted
Not Done

We could force this to one-per-line by adding a trailing comma.

durin42: We could force this to one-per-line by adding a trailing comma.
os.path.join(home, '.hgrc')]
userprofile = encoding.environ.get('USERPROFILE') userprofile = encoding.environ.get('USERPROFILE')
if userprofile and userprofile != home: if userprofile and userprofile != home:
path.append(os.path.join(userprofile, 'mercurial.ini')) path.append(os.path.join(userprofile, 'mercurial.ini'))
path.append(os.path.join(userprofile, '.hgrc')) path.append(os.path.join(userprofile, '.hgrc'))
return path return path
def termsize(ui): def termsize(ui):
return win32.termsize() return win32.termsize()

mercurial/state.py

# state.py - writing and reading state files in Mercurial # state.py - writing and reading state files in Mercurial
# #
# Copyright 2018 Pulkit Goyal <pulkitmgoyal@gmail.com> # Copyright 2018 Pulkit Goyal <pulkitmgoyal@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.
""" """
This file contains class to wrap the state for commands and other This file contains class to wrap the state for commands and other
related logic. related logic.
All the data related to the command state is stored as dictionary in the object. All the data related to the command state is stored as dictionary in the object.
The class has methods using which the data can be stored to disk in a file under The class has methods using which the data can be stored to disk in a file under
.hg/ directory. .hg/ directory.

tests/test-check-code.t

$ testrepohg files 'glob:*' $ testrepohg files 'glob:*'
.arcconfig .arcconfig
.clang-format .clang-format
.editorconfig .editorconfig
.hgignore .hgignore
.hgsigs .hgsigs
.hgtags .hgtags
.jshintrc .jshintrc
.style.yapf
CONTRIBUTING CONTRIBUTING
CONTRIBUTORS CONTRIBUTORS
COPYING COPYING
Makefile Makefile
README.rst README.rst
hg hg
hgeditor hgeditor
hgweb.cgi hgweb.cgi