ui: fold readsections into readconfig

readconfig now reads only single files
readconfig takes an optional list of sections
readconfig trusts files we're looking for sections in

hgext/acl.py

@@ -1,90 +1,90 b''
 # acl.py - changeset access control for mercurial
 #
 # Copyright 2006 Vadim Gelfer <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 #
 # this hook allows to allow or deny access to parts of a repo when
 # taking incoming changesets.
 #
 # authorization is against local user name on system where hook is
 # run, not committer of original changeset (since that is easy to
 # spoof).
 #
 # acl hook is best to use if you use hgsh to set up restricted shells
 # for authenticated users to only push to / pull from.  not safe if
 # user has interactive shell access, because they can disable hook.
 # also not safe if remote users share one local account, because then
 # no way to tell remote users apart.
 #
 # to use, configure acl extension in hgrc like this:
 #
 #   [extensions]
 #   hgext.acl =
 #
 #   [hooks]
 #   pretxnchangegroup.acl = python:hgext.acl.hook
 #
 #   [acl]
 #   sources = serve        # check if source of incoming changes in this list
 #                          # ("serve" == ssh or http, "push", "pull", "bundle")
 #
 # allow and deny lists have subtree pattern (default syntax is glob)
 # on left, user names on right. deny list checked before allow list.
 #
 #   [acl.allow]
 #   # if acl.allow not present, all users allowed by default
 #   # empty acl.allow = no users allowed
 #   docs/** = doc_writer
 #   .hgtags = release_engineer
 #
 #   [acl.deny]
 #   # if acl.deny not present, no users denied by default
 #   # empty acl.deny = all users allowed
 #   glob pattern = user4, user5
 #   ** = user6
 
 from mercurial.i18n import _
 from mercurial import util
 import getpass
 
 def buildmatch(ui, repo, user, key):
     '''return tuple of (match function, list enabled).'''
     if not ui.has_section(key):
         ui.debug(_('acl: %s not enabled\n') % key)
         return None
 
     pats = [pat for pat, users in ui.configitems(key)
             if user in users.replace(',', ' ').split()]
     ui.debug(_('acl: %s enabled, %d entries for user %s\n') %
              (key, len(pats), user))
     if pats:
         return util.matcher(repo.root, names=pats)[1]
     return util.never
 
 def hook(ui, repo, hooktype, node=None, source=None, **kwargs):
     if hooktype != 'pretxnchangegroup':
         raise util.Abort(_('config error - hook type "%s" cannot stop '
                            'incoming changesets') % hooktype)
     if source not in ui.config('acl', 'sources', 'serve').split():
         ui.debug(_('acl: changes have source "%s" - skipping\n') % source)
         return
 
     user = getpass.getuser()
     cfg = ui.config('acl', 'config')
     if cfg:
-        ui.readsections(cfg, 'acl.allow', 'acl.deny')
+        ui.readconfig(cfg, sections = ['acl.allow', 'acl.deny'])
     allow = buildmatch(ui, repo, user, 'acl.allow')
     deny = buildmatch(ui, repo, user, 'acl.deny')
 
     for rev in xrange(repo[node], len(repo)):
         ctx = repo[rev]
         for f in ctx.files():
             if deny and deny(f):
                 ui.debug(_('acl: user %s denied on %s\n') % (user, f))
                 raise util.Abort(_('acl: access denied for changeset %s') % ctx)
             if allow and not allow(f):
                 ui.debug(_('acl: user %s not allowed on %s\n') % (user, f))
                 raise util.Abort(_('acl: access denied for changeset %s') % ctx)
         ui.debug(_('acl: allowing changeset %s\n') % ctx)

hgext/bugzilla.py

@@ -1,417 +1,417 b''
 # bugzilla.py - bugzilla integration for mercurial
 #
 # Copyright 2006 Vadim Gelfer <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 '''Bugzilla integration
 
 This hook extension adds comments on bugs in Bugzilla when changesets
 that refer to bugs by Bugzilla ID are seen. The hook does not change
 bug status.
 
 The hook updates the Bugzilla database directly. Only Bugzilla
 installations using MySQL are supported.
 
 The hook relies on a Bugzilla script to send bug change notification
 emails. That script changes between Bugzilla versions; the
 'processmail' script used prior to 2.18 is replaced in 2.18 and
 subsequent versions by 'config/sendbugmail.pl'. Note that these will
 be run by Mercurial as the user pushing the change; you will need to
 ensure the Bugzilla install file permissions are set appropriately.
 
 Configuring the extension:
 
     [bugzilla]
 
     host       Hostname of the MySQL server holding the Bugzilla
                database.
     db         Name of the Bugzilla database in MySQL. Default 'bugs'.
     user       Username to use to access MySQL server. Default 'bugs'.
     password   Password to use to access MySQL server.
     timeout    Database connection timeout (seconds). Default 5.
     version    Bugzilla version. Specify '3.0' for Bugzilla versions
                3.0 and later, '2.18' for Bugzilla versions from 2.18
                and '2.16' for versions prior to 2.18.
     bzuser     Fallback Bugzilla user name to record comments with, if
                changeset committer cannot be found as a Bugzilla user.
     bzdir      Bugzilla install directory. Used by default notify.
                Default '/var/www/html/bugzilla'.
     notify     The command to run to get Bugzilla to send bug change
                notification emails. Substitutes from a map with 3
                keys, 'bzdir', 'id' (bug id) and 'user' (committer
                bugzilla email). Default depends on version; from 2.18
                it is "cd %(bzdir)s && perl -T contrib/sendbugmail.pl
                %(id)s %(user)s".
     regexp     Regular expression to match bug IDs in changeset commit
                message. Must contain one "()" group. The default
                expression matches 'Bug 1234', 'Bug no. 1234', 'Bug
                number 1234', 'Bugs 1234,5678', 'Bug 1234 and 5678' and
                variations thereof. Matching is case insensitive.
     style      The style file to use when formatting comments.
     template   Template to use when formatting comments. Overrides
                style if specified. In addition to the usual Mercurial
                keywords, the extension specifies:
                    {bug}       The Bugzilla bug ID.
                    {root}      The full pathname of the Mercurial
                                repository.
                    {webroot}   Stripped pathname of the Mercurial
                                repository.
                    {hgweb}     Base URL for browsing Mercurial
                                repositories.
                Default 'changeset {node|short} in repo {root} refers '
                        'to bug {bug}.\\ndetails:\\n\\t{desc|tabindent}'
     strip      The number of slashes to strip from the front of {root}
                to produce {webroot}. Default 0.
     usermap    Path of file containing Mercurial committer ID to
                Bugzilla user ID mappings. If specified, the file
                should contain one mapping per line,
                "committer"="Bugzilla user". See also the [usermap]
                section.
 
     [usermap]
     Any entries in this section specify mappings of Mercurial
     committer ID to Bugzilla user ID. See also [bugzilla].usermap.
     "committer"="Bugzilla user"
 
     [web]
     baseurl    Base URL for browsing Mercurial repositories. Reference
                from templates as {hgweb}.
 
 Activating the extension:
 
     [extensions]
     hgext.bugzilla =
 
     [hooks]
     # run bugzilla hook on every change pulled or pushed in here
     incoming.bugzilla = python:hgext.bugzilla.hook
 
 Example configuration:
 
 This example configuration is for a collection of Mercurial
 repositories in /var/local/hg/repos/ used with a local Bugzilla 3.2
 installation in /opt/bugzilla-3.2.
 
     [bugzilla]
     host=localhost
     password=XYZZY
     version=3.0
     bzuser=[e-mail]
     bzdir=/opt/bugzilla-3.2
     template=Changeset {node|short} in {root|basename}.\\n{hgweb}/{webroot}/rev/{node|short}\\n\\n{desc}\\n
     strip=5
 
     [web]
     baseurl=http://dev.domain.com/hg
 
     [usermap]
     [e-mail]=[e-mail]
 
 Commits add a comment to the Bugzilla bug record of the form:
 
     Changeset 3b16791d6642 in repository-name.
     http://dev.domain.com/hg/repository-name/rev/3b16791d6642
 
     Changeset commit comment. Bug 1234.
 '''
 
 from mercurial.i18n import _
 from mercurial.node import short
 from mercurial import cmdutil, templater, util
 import re, time
 
 MySQLdb = None
 
 def buglist(ids):
     return '(' + ','.join(map(str, ids)) + ')'
 
 class bugzilla_2_16(object):
     '''support for bugzilla version 2.16.'''
 
     def __init__(self, ui):
         self.ui = ui
         host = self.ui.config('bugzilla', 'host', 'localhost')
         user = self.ui.config('bugzilla', 'user', 'bugs')
         passwd = self.ui.config('bugzilla', 'password')
         db = self.ui.config('bugzilla', 'db', 'bugs')
         timeout = int(self.ui.config('bugzilla', 'timeout', 5))
         usermap = self.ui.config('bugzilla', 'usermap')
         if usermap:
-            self.ui.readsections(usermap, 'usermap')
+            self.ui.readconfig(usermap, 'usermap')
         self.ui.note(_('connecting to %s:%s as %s, password %s\n') %
                      (host, db, user, '*' * len(passwd)))
         self.conn = MySQLdb.connect(host=host, user=user, passwd=passwd,
                                     db=db, connect_timeout=timeout)
         self.cursor = self.conn.cursor()
         self.longdesc_id = self.get_longdesc_id()
         self.user_ids = {}
         self.default_notify = "cd %(bzdir)s && ./processmail %(id)s %(user)s"
 
     def run(self, *args, **kwargs):
         '''run a query.'''
         self.ui.note(_('query: %s %s\n') % (args, kwargs))
         try:
             self.cursor.execute(*args, **kwargs)
         except MySQLdb.MySQLError:
             self.ui.note(_('failed query: %s %s\n') % (args, kwargs))
             raise
 
     def get_longdesc_id(self):
         '''get identity of longdesc field'''
         self.run('select fieldid from fielddefs where name = "longdesc"')
         ids = self.cursor.fetchall()
         if len(ids) != 1:
             raise util.Abort(_('unknown database schema'))
         return ids[0][0]
 
     def filter_real_bug_ids(self, ids):
         '''filter not-existing bug ids from list.'''
         self.run('select bug_id from bugs where bug_id in %s' % buglist(ids))
         return util.sort([c[0] for c in self.cursor.fetchall()])
 
     def filter_unknown_bug_ids(self, node, ids):
         '''filter bug ids from list that already refer to this changeset.'''
 
         self.run('''select bug_id from longdescs where
                     bug_id in %s and thetext like "%%%s%%"''' %
                  (buglist(ids), short(node)))
         unknown = dict.fromkeys(ids)
         for (id,) in self.cursor.fetchall():
             self.ui.status(_('bug %d already knows about changeset %s\n') %
                            (id, short(node)))
             unknown.pop(id, None)
         return util.sort(unknown.keys())
 
     def notify(self, ids, committer):
         '''tell bugzilla to send mail.'''
 
         self.ui.status(_('telling bugzilla to send mail:\n'))
         (user, userid) = self.get_bugzilla_user(committer)
         for id in ids:
             self.ui.status(_('  bug %s\n') % id)
             cmdfmt = self.ui.config('bugzilla', 'notify', self.default_notify)
             bzdir = self.ui.config('bugzilla', 'bzdir', '/var/www/html/bugzilla')
             try:
                 # Backwards-compatible with old notify string, which
                 # took one string. This will throw with a new format
                 # string.
                 cmd = cmdfmt % id
             except TypeError:
                 cmd = cmdfmt % {'bzdir': bzdir, 'id': id, 'user': user}
             self.ui.note(_('running notify command %s\n') % cmd)
             fp = util.popen('(%s) 2>&1' % cmd)
             out = fp.read()
             ret = fp.close()
             if ret:
                 self.ui.warn(out)
                 raise util.Abort(_('bugzilla notify command %s') %
                                  util.explain_exit(ret)[0])
         self.ui.status(_('done\n'))
 
     def get_user_id(self, user):
         '''look up numeric bugzilla user id.'''
         try:
             return self.user_ids[user]
         except KeyError:
             try:
                 userid = int(user)
             except ValueError:
                 self.ui.note(_('looking up user %s\n') % user)
                 self.run('''select userid from profiles
                             where login_name like %s''', user)
                 all = self.cursor.fetchall()
                 if len(all) != 1:
                     raise KeyError(user)
                 userid = int(all[0][0])
             self.user_ids[user] = userid
             return userid
 
     def map_committer(self, user):
         '''map name of committer to bugzilla user name.'''
         for committer, bzuser in self.ui.configitems('usermap'):
             if committer.lower() == user.lower():
                 return bzuser
         return user
 
     def get_bugzilla_user(self, committer):
         '''see if committer is a registered bugzilla user. Return
         bugzilla username and userid if so. If not, return default
         bugzilla username and userid.'''
         user = self.map_committer(committer)
         try:
             userid = self.get_user_id(user)
         except KeyError:
             try:
                 defaultuser = self.ui.config('bugzilla', 'bzuser')
                 if not defaultuser:
                     raise util.Abort(_('cannot find bugzilla user id for %s') %
                                      user)
                 userid = self.get_user_id(defaultuser)
                 user = defaultuser
             except KeyError:
                 raise util.Abort(_('cannot find bugzilla user id for %s or %s') %
                                  (user, defaultuser))
         return (user, userid)
 
     def add_comment(self, bugid, text, committer):
         '''add comment to bug. try adding comment as committer of
         changeset, otherwise as default bugzilla user.'''
         (user, userid) = self.get_bugzilla_user(committer)
         now = time.strftime('%Y-%m-%d %H:%M:%S')
         self.run('''insert into longdescs
                     (bug_id, who, bug_when, thetext)
                     values (%s, %s, %s, %s)''',
                  (bugid, userid, now, text))
         self.run('''insert into bugs_activity (bug_id, who, bug_when, fieldid)
                     values (%s, %s, %s, %s)''',
                  (bugid, userid, now, self.longdesc_id))
         self.conn.commit()
 
 class bugzilla_2_18(bugzilla_2_16):
     '''support for bugzilla 2.18 series.'''
 
     def __init__(self, ui):
         bugzilla_2_16.__init__(self, ui)
         self.default_notify = "cd %(bzdir)s && perl -T contrib/sendbugmail.pl %(id)s %(user)s"
 
 class bugzilla_3_0(bugzilla_2_18):
     '''support for bugzilla 3.0 series.'''
 
     def __init__(self, ui):
         bugzilla_2_18.__init__(self, ui)
 
     def get_longdesc_id(self):
         '''get identity of longdesc field'''
         self.run('select id from fielddefs where name = "longdesc"')
         ids = self.cursor.fetchall()
         if len(ids) != 1:
             raise util.Abort(_('unknown database schema'))
         return ids[0][0]
 
 class bugzilla(object):
     # supported versions of bugzilla. different versions have
     # different schemas.
     _versions = {
         '2.16': bugzilla_2_16,
         '2.18': bugzilla_2_18,
         '3.0':  bugzilla_3_0
         }
 
     _default_bug_re = (r'bugs?\s*,?\s*(?:#|nos?\.?|num(?:ber)?s?)?\s*'
                        r'((?:\d+\s*(?:,?\s*(?:and)?)?\s*)+)')
 
     _bz = None
 
     def __init__(self, ui, repo):
         self.ui = ui
         self.repo = repo
 
     def bz(self):
         '''return object that knows how to talk to bugzilla version in
         use.'''
 
         if bugzilla._bz is None:
             bzversion = self.ui.config('bugzilla', 'version')
             try:
                 bzclass = bugzilla._versions[bzversion]
             except KeyError:
                 raise util.Abort(_('bugzilla version %s not supported') %
                                  bzversion)
             bugzilla._bz = bzclass(self.ui)
         return bugzilla._bz
 
     def __getattr__(self, key):
         return getattr(self.bz(), key)
 
     _bug_re = None
     _split_re = None
 
     def find_bug_ids(self, ctx):
         '''find valid bug ids that are referred to in changeset
         comments and that do not already have references to this
         changeset.'''
 
         if bugzilla._bug_re is None:
             bugzilla._bug_re = re.compile(
                 self.ui.config('bugzilla', 'regexp', bugzilla._default_bug_re),
                 re.IGNORECASE)
             bugzilla._split_re = re.compile(r'\D+')
         start = 0
         ids = {}
         while True:
             m = bugzilla._bug_re.search(ctx.description(), start)
             if not m:
                 break
             start = m.end()
             for id in bugzilla._split_re.split(m.group(1)):
                 if not id: continue
                 ids[int(id)] = 1
         ids = ids.keys()
         if ids:
             ids = self.filter_real_bug_ids(ids)
         if ids:
             ids = self.filter_unknown_bug_ids(ctx.node(), ids)
         return ids
 
     def update(self, bugid, ctx):
         '''update bugzilla bug with reference to changeset.'''
 
         def webroot(root):
             '''strip leading prefix of repo root and turn into
             url-safe path.'''
             count = int(self.ui.config('bugzilla', 'strip', 0))
             root = util.pconvert(root)
             while count > 0:
                 c = root.find('/')
                 if c == -1:
                     break
                 root = root[c+1:]
                 count -= 1
             return root
 
         mapfile = self.ui.config('bugzilla', 'style')
         tmpl = self.ui.config('bugzilla', 'template')
         t = cmdutil.changeset_templater(self.ui, self.repo,
                                         False, None, mapfile, False)
         if not mapfile and not tmpl:
             tmpl = _('changeset {node|short} in repo {root} refers '
                      'to bug {bug}.\ndetails:\n\t{desc|tabindent}')
         if tmpl:
             tmpl = templater.parsestring(tmpl, quoted=False)
             t.use_template(tmpl)
         self.ui.pushbuffer()
         t.show(ctx, changes=ctx.changeset(),
                bug=str(bugid),
                hgweb=self.ui.config('web', 'baseurl'),
                root=self.repo.root,
                webroot=webroot(self.repo.root))
         data = self.ui.popbuffer()
         self.add_comment(bugid, data, util.email(ctx.user()))
 
 def hook(ui, repo, hooktype, node=None, **kwargs):
     '''add comment to bugzilla for each changeset that refers to a
     bugzilla bug id. only add a comment once per bug, so same change
     seen multiple times does not fill bug with duplicate data.'''
     try:
         import MySQLdb as mysql
         global MySQLdb
         MySQLdb = mysql
     except ImportError, err:
         raise util.Abort(_('python mysql support not available: %s') % err)
 
     if node is None:
         raise util.Abort(_('hook type %s does not pass a changeset id') %
                          hooktype)
     try:
         bz = bugzilla(ui, repo)
         ctx = repo[node]
         ids = bz.find_bug_ids(ctx)
         if ids:
             for id in ids:
                 bz.update(id, ctx)
             bz.notify(ids, util.email(ctx.user()))
     except MySQLdb.MySQLError, err:
         raise util.Abort(_('database error: %s') % err[1])
 

hgext/notify.py

@@ -1,290 +1,290 b''
 # notify.py - email notifications for mercurial
 #
 # Copyright 2006 Vadim Gelfer <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 '''hook extension to email notifications on commits/pushes
 
 Subscriptions can be managed through hgrc. Default mode is to print
 messages to stdout, for testing and configuring.
 
 To use, configure notify extension and enable in hgrc like this:
 
    [extensions]
    hgext.notify =
 
    [hooks]
    # one email for each incoming changeset
    incoming.notify = python:hgext.notify.hook
    # batch emails when many changesets incoming at one time
    changegroup.notify = python:hgext.notify.hook
 
    [notify]
    # config items go in here
 
  config items:
 
  REQUIRED:
    config = /path/to/file # file containing subscriptions
 
  OPTIONAL:
    test = True            # print messages to stdout for testing
    strip = 3              # number of slashes to strip for url paths
    domain = example.com   # domain to use if committer missing domain
    style = ...            # style file to use when formatting email
    template = ...         # template to use when formatting email
    incoming = ...         # template to use when run as incoming hook
    changegroup = ...      # template when run as changegroup hook
    maxdiff = 300          # max lines of diffs to include (0=none, -1=all)
    maxsubject = 67        # truncate subject line longer than this
    diffstat = True        # add a diffstat before the diff content
    sources = serve        # notify if source of incoming changes in this list
                           # (serve == ssh or http, push, pull, bundle)
    [email]
    from = [e-mail]   # email address to send as if none given
    [web]
    baseurl = http://hgserver/... # root of hg web site for browsing commits
 
  notify config file has same format as regular hgrc. it has two
  sections so you can express subscriptions in whatever way is handier
  for you.
 
    [usersubs]
    # key is subscriber email, value is ","-separated list of glob patterns
    user@host = pattern
 
    [reposubs]
    # key is glob pattern, value is ","-separated list of subscriber emails
    pattern = user@host
 
  glob patterns are matched against path to repository root.
 
  if you like, you can put notify config file in repository that users
  can push changes to, they can manage their own subscriptions.'''
 
 from mercurial.i18n import _
 from mercurial import patch, cmdutil, templater, util, mail
 import email.Parser, fnmatch, socket, time
 
 # template for single changeset can include email headers.
 single_template = '''
 Subject: changeset in {webroot}: {desc|firstline|strip}
 From: {author}
 
 changeset {node|short} in {root}
 details: {baseurl}{webroot}?cmd=changeset;node={node|short}
 description:
 \t{desc|tabindent|strip}
 '''.lstrip()
 
 # template for multiple changesets should not contain email headers,
 # because only first set of headers will be used and result will look
 # strange.
 multiple_template = '''
 changeset {node|short} in {root}
 details: {baseurl}{webroot}?cmd=changeset;node={node|short}
 summary: {desc|firstline}
 '''
 
 deftemplates = {
     'changegroup': multiple_template,
 }
 
 class notifier(object):
     '''email notification class.'''
 
     def __init__(self, ui, repo, hooktype):
         self.ui = ui
         cfg = self.ui.config('notify', 'config')
         if cfg:
-            self.ui.readsections(cfg, 'usersubs', 'reposubs')
+            self.ui.readconfig(cfg, sections=['usersubs', 'reposubs'])
         self.repo = repo
         self.stripcount = int(self.ui.config('notify', 'strip', 0))
         self.root = self.strip(self.repo.root)
         self.domain = self.ui.config('notify', 'domain')
         self.test = self.ui.configbool('notify', 'test', True)
         self.charsets = mail._charsets(self.ui)
         self.subs = self.subscribers()
 
         mapfile = self.ui.config('notify', 'style')
         template = (self.ui.config('notify', hooktype) or
                     self.ui.config('notify', 'template'))
         self.t = cmdutil.changeset_templater(self.ui, self.repo,
                                              False, None, mapfile, False)
         if not mapfile and not template:
             template = deftemplates.get(hooktype) or single_template
         if template:
             template = templater.parsestring(template, quoted=False)
             self.t.use_template(template)
 
     def strip(self, path):
         '''strip leading slashes from local path, turn into web-safe path.'''
 
         path = util.pconvert(path)
         count = self.stripcount
         while count > 0:
             c = path.find('/')
             if c == -1:
                 break
             path = path[c+1:]
             count -= 1
         return path
 
     def fixmail(self, addr):
         '''try to clean up email addresses.'''
 
         addr = util.email(addr.strip())
         if self.domain:
             a = addr.find('@localhost')
             if a != -1:
                 addr = addr[:a]
             if '@' not in addr:
                 return addr + '@' + self.domain
         return addr
 
     def subscribers(self):
         '''return list of email addresses of subscribers to this repo.'''
         subs = {}
         for user, pats in self.ui.configitems('usersubs'):
             for pat in pats.split(','):
                 if fnmatch.fnmatch(self.repo.root, pat.strip()):
                     subs[self.fixmail(user)] = 1
         for pat, users in self.ui.configitems('reposubs'):
             if fnmatch.fnmatch(self.repo.root, pat):
                 for user in users.split(','):
                     subs[self.fixmail(user)] = 1
         subs = util.sort(subs)
         return [mail.addressencode(self.ui, s, self.charsets, self.test)
                 for s in subs]
 
     def url(self, path=None):
         return self.ui.config('web', 'baseurl') + (path or self.root)
 
     def node(self, ctx):
         '''format one changeset.'''
         self.t.show(ctx, changes=ctx.changeset(),
                     baseurl=self.ui.config('web', 'baseurl'),
                     root=self.repo.root, webroot=self.root)
 
     def skipsource(self, source):
         '''true if incoming changes from this source should be skipped.'''
         ok_sources = self.ui.config('notify', 'sources', 'serve').split()
         return source not in ok_sources
 
     def send(self, ctx, count, data):
         '''send message.'''
 
         p = email.Parser.Parser()
         msg = p.parsestr(data)
 
         # store sender and subject
         sender, subject = msg['From'], msg['Subject']
         del msg['From'], msg['Subject']
         # store remaining headers
         headers = msg.items()
         # create fresh mime message from msg body
         text = msg.get_payload()
         # for notification prefer readability over data precision
         msg = mail.mimeencode(self.ui, text, self.charsets, self.test)
         # reinstate custom headers
         for k, v in headers:
             msg[k] = v
 
         msg['Date'] = util.datestr(format="%a, %d %b %Y %H:%M:%S %1%2")
 
         # try to make subject line exist and be useful
         if not subject:
             if count > 1:
                 subject = _('%s: %d new changesets') % (self.root, count)
             else:
                 s = ctx.description().lstrip().split('\n', 1)[0].rstrip()
                 subject = '%s: %s' % (self.root, s)
         maxsubject = int(self.ui.config('notify', 'maxsubject', 67))
         if maxsubject and len(subject) > maxsubject:
             subject = subject[:maxsubject-3] + '...'
         msg['Subject'] = mail.headencode(self.ui, subject,
                                          self.charsets, self.test)
 
         # try to make message have proper sender
         if not sender:
             sender = self.ui.config('email', 'from') or self.ui.username()
         if '@' not in sender or '@localhost' in sender:
             sender = self.fixmail(sender)
         msg['From'] = mail.addressencode(self.ui, sender,
                                          self.charsets, self.test)
 
         msg['X-Hg-Notification'] = 'changeset %s' % ctx
         if not msg['Message-Id']:
             msg['Message-Id'] = ('<hg.%s.%s.%s@%s>' %
                                  (ctx, int(time.time()),
                                   hash(self.repo.root), socket.getfqdn()))
         msg['To'] = ', '.join(self.subs)
 
         msgtext = msg.as_string(0)
         if self.test:
             self.ui.write(msgtext)
             if not msgtext.endswith('\n'):
                 self.ui.write('\n')
         else:
             self.ui.status(_('notify: sending %d subscribers %d changes\n') %
                            (len(self.subs), count))
             mail.sendmail(self.ui, util.email(msg['From']),
                           self.subs, msgtext)
 
     def diff(self, ctx, ref=None):
 
         maxdiff = int(self.ui.config('notify', 'maxdiff', 300))
         prev = ctx.parents()[0].node()
         ref = ref and ref.node() or ctx.node()
         chunks = patch.diff(self.repo, prev, ref, opts=patch.diffopts(self.ui))
         difflines = ''.join(chunks).splitlines()
 
         if self.ui.configbool('notify', 'diffstat', True):
             s = patch.diffstat(difflines)
             # s may be nil, don't include the header if it is
             if s:
                 self.ui.write('\ndiffstat:\n\n%s' % s)
 
         if maxdiff == 0:
             return
         elif maxdiff > 0 and len(difflines) > maxdiff:
             msg = _('\ndiffs (truncated from %d to %d lines):\n\n')
             self.ui.write(msg % (len(difflines), maxdiff))
             difflines = difflines[:maxdiff]
         elif difflines:
             self.ui.write(_('\ndiffs (%d lines):\n\n') % len(difflines))
 
         self.ui.write("\n".join(difflines))
 
 def hook(ui, repo, hooktype, node=None, source=None, **kwargs):
     '''send email notifications to interested subscribers.
 
     if used as changegroup hook, send one email for all changesets in
     changegroup. else send one email per changeset.'''
 
     n = notifier(ui, repo, hooktype)
     ctx = repo[node]
 
     if not n.subs:
         ui.debug(_('notify: no subscribers to repository %s\n') % n.root)
         return
     if n.skipsource(source):
         ui.debug(_('notify: changes have source "%s" - skipping\n') % source)
         return
 
     ui.pushbuffer()
     if hooktype == 'changegroup':
         start, end = ctx.rev(), len(repo)
         count = end - start
         for rev in xrange(start, end):
             n.node(repo[rev])
         n.diff(ctx, repo['tip'])
     else:
         count = 1
         n.node(ctx)
         n.diff(ctx)
 
     data = ui.popbuffer()
     n.send(ctx, count, data)

mercurial/ui.py

@@ -1,435 +1,409 b''
 # ui.py - user interface bits for mercurial
 #
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 from i18n import _
 import errno, getpass, os, re, socket, sys, tempfile
 import ConfigParser, traceback, util
 
 def dupconfig(orig):
     new = util.configparser(orig.defaults())
     updateconfig(orig, new)
     return new
 
 def updateconfig(source, dest, sections=None):
     if not sections:
         sections = source.sections()
     for section in sections:
         if not dest.has_section(section):
             dest.add_section(section)
+        if not source.has_section(section):
+            continue
         for name, value in source.items(section, raw=True):
             dest.set(section, name, value)
 
 class ui(object):
     def __init__(self, parentui=None):
         self.buffers = []
         self.quiet = self.verbose = self.debugflag = self.traceback = False
         self.interactive = self.report_untrusted = True
 
         if parentui is None:
             # this is the parent of all ui children
             self.parentui = None
             self.trusted_users = {}
             self.trusted_groups = {}
             self.overlay = util.configparser()
             self.cdata = util.configparser()
             self.ucdata = util.configparser()
 
             # we always trust global config files
-            self.readconfig(util.rcpath(), assumetrusted=True)
+            for f in util.rcpath():
+                self.readconfig(f, assumetrusted=True)
         else:
             # parentui may point to an ui object which is already a child
             self.parentui = parentui.parentui or parentui
             self.buffers = parentui.buffers
             self.trusted_users = parentui.trusted_users.copy()
             self.trusted_groups = parentui.trusted_groups.copy()
             self.cdata = dupconfig(self.parentui.cdata)
             self.ucdata = dupconfig(self.parentui.ucdata)
 
             # we want the overlay from the parent, not the root
             self.overlay = dupconfig(parentui.overlay)
+            self.fixconfig()
 
     def __getattr__(self, key):
         return getattr(self.parentui, key)
 
     _isatty = None
     def isatty(self):
         if ui._isatty is None:
             try:
                 ui._isatty = sys.stdin.isatty()
             except AttributeError: # not a real file object
                 ui._isatty = False
         return ui._isatty
 
     def _is_trusted(self, fp, f):
         st = util.fstat(fp)
         if util.isowner(fp, st):
             return True
 
         tusers = self.trusted_users
         tgroups = self.trusted_groups
         if '*' in tusers or '*' in tgroups:
             return True
 
         user = util.username(st.st_uid)
         group = util.groupname(st.st_gid)
         if user in tusers or group in tgroups or user == util.username():
             return True
 
         if self.report_untrusted:
             self.warn(_('Not trusting file %s from untrusted '
                         'user %s, group %s\n') % (f, user, group))
         return False
 
-    def readconfig(self, fn, root=None, assumetrusted=False):
-        cdata = util.configparser()
+    def readconfig(self, filename, root=None, assumetrusted=False,
+                   sections = None):
+        try:
+            fp = open(filename)
+        except IOError:
+            if not sections: # ignore unless we were looking for something
+                return
+            raise
 
-        if isinstance(fn, basestring):
-            fn = [fn]
-        for f in fn:
-            try:
-                fp = open(f)
-            except IOError:
-                continue
-
-            trusted = assumetrusted or self._is_trusted(fp, f)
+        cdata = util.configparser()
+        trusted = sections or assumetrusted or self._is_trusted(fp, filename)
 
-            try:
-                cdata.readfp(fp, f)
-            except ConfigParser.ParsingError, inst:
-                msg = _("Failed to parse %s\n%s") % (f, inst)
-                if trusted:
-                    raise util.Abort(msg)
-                self.warn(_("Ignored: %s\n") % msg)
+        try:
+            cdata.readfp(fp, filename)
+        except ConfigParser.ParsingError, inst:
+            msg = _("Failed to parse %s\n%s") % (filename, inst)
+            if trusted:
+                raise util.Abort(msg)
+            self.warn(_("Ignored: %s\n") % msg)
 
-            if trusted:
-                updateconfig(cdata, self.cdata)
-                updateconfig(self.overlay, self.cdata)
-            updateconfig(cdata, self.ucdata)
-            updateconfig(self.overlay, self.ucdata)
+        if trusted:
+            updateconfig(cdata, self.cdata, sections)
+            updateconfig(self.overlay, self.cdata, sections)
+        updateconfig(cdata, self.ucdata, sections)
+        updateconfig(self.overlay, self.ucdata, sections)
 
         if root is None:
             root = os.path.expanduser('~')
         self.fixconfig(root=root)
 
-    def readsections(self, filename, *sections):
-        """Read filename and add only the specified sections to the config data
-
-        The settings are added to the trusted config data.
-        """
-        if not sections:
-            return
-
-        cdata = util.configparser()
-        try:
-            try:
-                fp = open(filename)
-            except IOError, inst:
-                raise util.Abort(_("unable to open %s: %s") %
-                                 (filename, getattr(inst, "strerror", inst)))
-            try:
-                cdata.readfp(fp, filename)
-            finally:
-                fp.close()
-        except ConfigParser.ParsingError, inst:
-            raise util.Abort(_("failed to parse %s\n%s") % (filename, inst))
-
-        for section in sections:
-            if not cdata.has_section(section):
-                cdata.add_section(section)
-
-        updateconfig(cdata, self.cdata, sections)
-        updateconfig(cdata, self.ucdata, sections)
-
     def fixconfig(self, section=None, name=None, value=None, root=None):
         # translate paths relative to root (or home) into absolute paths
         if section is None or section == 'paths':
             if root is None:
                 root = os.getcwd()
             items = section and [(name, value)] or []
             for cdata in self.cdata, self.ucdata, self.overlay:
                 if not items and cdata.has_section('paths'):
                     pathsitems = cdata.items('paths')
                 else:
                     pathsitems = items
                 for n, path in pathsitems:
                     if path and "://" not in path and not os.path.isabs(path):
                         cdata.set("paths", n,
                                   os.path.normpath(os.path.join(root, path)))
 
         # update ui options
         if section is None or section == 'ui':
             self.debugflag = self.configbool('ui', 'debug')
             self.verbose = self.debugflag or self.configbool('ui', 'verbose')
             self.quiet = not self.debugflag and self.configbool('ui', 'quiet')
             if self.verbose and self.quiet:
                 self.quiet = self.verbose = False
 
             self.report_untrusted = self.configbool("ui", "report_untrusted",
                                                     True)
             self.interactive = self.configbool("ui", "interactive",
                                                self.isatty())
             self.traceback = self.configbool('ui', 'traceback', False)
 
         # update trust information
         if section is None or section == 'trusted':
             for user in self.configlist('trusted', 'users'):
                 self.trusted_users[user] = 1
             for group in self.configlist('trusted', 'groups'):
                 self.trusted_groups[group] = 1
 
     def setconfig(self, section, name, value):
         for cdata in (self.overlay, self.cdata, self.ucdata):
             if not cdata.has_section(section):
                 cdata.add_section(section)
             cdata.set(section, name, value)
         self.fixconfig(section, name, value)
 
     def _get_cdata(self, untrusted):
         if untrusted:
             return self.ucdata
         return self.cdata
 
     def _config(self, section, name, default, funcname, untrusted, abort):
         cdata = self._get_cdata(untrusted)
         if cdata.has_option(section, name):
             try:
                 func = getattr(cdata, funcname)
                 return func(section, name)
             except (ConfigParser.InterpolationError, ValueError), inst:
                 msg = _("Error in configuration section [%s] "
                         "parameter '%s':\n%s") % (section, name, inst)
                 if abort:
                     raise util.Abort(msg)
                 self.warn(_("Ignored: %s\n") % msg)
         return default
 
     def _configcommon(self, section, name, default, funcname, untrusted):
         value = self._config(section, name, default, funcname,
                              untrusted, abort=True)
         if self.debugflag and not untrusted:
             uvalue = self._config(section, name, None, funcname,
                                   untrusted=True, abort=False)
             if uvalue is not None and uvalue != value:
                 self.warn(_("Ignoring untrusted configuration option "
                             "%s.%s = %s\n") % (section, name, uvalue))
         return value
 
     def config(self, section, name, default=None, untrusted=False):
         return self._configcommon(section, name, default, 'get', untrusted)
 
     def configbool(self, section, name, default=False, untrusted=False):
         return self._configcommon(section, name, default, 'getboolean',
                                   untrusted)
 
     def configlist(self, section, name, default=None, untrusted=False):
         """Return a list of comma/space separated strings"""
         result = self.config(section, name, untrusted=untrusted)
         if result is None:
             result = default or []
         if isinstance(result, basestring):
             result = result.replace(",", " ").split()
         return result
 
     def has_section(self, section, untrusted=False):
         '''tell whether section exists in config.'''
         cdata = self._get_cdata(untrusted)
         return cdata.has_section(section)
 
     def _configitems(self, section, untrusted, abort):
         items = {}
         cdata = self._get_cdata(untrusted)
         if cdata.has_section(section):
             try:
                 items.update(dict(cdata.items(section)))
             except ConfigParser.InterpolationError, inst:
                 msg = _("Error in configuration section [%s]:\n"
                         "%s") % (section, inst)
                 if abort:
                     raise util.Abort(msg)
                 self.warn(_("Ignored: %s\n") % msg)
         return items
 
     def configitems(self, section, untrusted=False):
         items = self._configitems(section, untrusted=untrusted, abort=True)
         if self.debugflag and not untrusted:
             uitems = self._configitems(section, untrusted=True, abort=False)
             for k in util.sort(uitems):
                 if uitems[k] != items.get(k):
                     self.warn(_("Ignoring untrusted configuration option "
                                 "%s.%s = %s\n") % (section, k, uitems[k]))
         return util.sort(items.items())
 
     def walkconfig(self, untrusted=False):
         cdata = self._get_cdata(untrusted)
         sections = cdata.sections()
         sections.sort()
         for section in sections:
             for name, value in self.configitems(section, untrusted):
                 yield section, name, str(value).replace('\n', '\\n')
 
     def username(self):
         """Return default username to be used in commits.
 
         Searched in this order: $HGUSER, [ui] section of hgrcs, $EMAIL
         and stop searching if one of these is set.
         If not found and ui.askusername is True, ask the user, else use
         ($LOGNAME or $USER or $LNAME or $USERNAME) + "@full.hostname".
         """
         user = os.environ.get("HGUSER")
         if user is None:
             user = self.config("ui", "username")
         if user is None:
             user = os.environ.get("EMAIL")
         if user is None and self.configbool("ui", "askusername"):
             user = self.prompt(_("enter a commit username:"), default=None)
         if user is None:
             try:
                 user = '%s@%s' % (util.getuser(), socket.getfqdn())
                 self.warn(_("No username found, using '%s' instead\n") % user)
             except KeyError:
                 pass
         if not user:
             raise util.Abort(_("Please specify a username."))
         if "\n" in user:
             raise util.Abort(_("username %s contains a newline\n") % repr(user))
         return user
 
     def shortuser(self, user):
         """Return a short representation of a user name or email address."""
         if not self.verbose: user = util.shortuser(user)
         return user
 
     def expandpath(self, loc, default=None):
         """Return repository location relative to cwd or from [paths]"""
         if "://" in loc or os.path.isdir(os.path.join(loc, '.hg')):
             return loc
 
         path = self.config("paths", loc)
         if not path and default is not None:
             path = self.config("paths", default)
         return path or loc
 
     def pushbuffer(self):
         self.buffers.append([])
 
     def popbuffer(self):
         return "".join(self.buffers.pop())
 
     def write(self, *args):
         if self.buffers:
             self.buffers[-1].extend([str(a) for a in args])
         else:
             for a in args:
                 sys.stdout.write(str(a))
 
     def write_err(self, *args):
         try:
             if not sys.stdout.closed: sys.stdout.flush()
             for a in args:
                 sys.stderr.write(str(a))
             # stderr may be buffered under win32 when redirected to files,
             # including stdout.
             if not sys.stderr.closed: sys.stderr.flush()
         except IOError, inst:
             if inst.errno != errno.EPIPE:
                 raise
 
     def flush(self):
         try: sys.stdout.flush()
         except: pass
         try: sys.stderr.flush()
         except: pass
 
     def _readline(self, prompt=''):
         if self.isatty():
             try:
                 # magically add command line editing support, where
                 # available
                 import readline
                 # force demandimport to really load the module
                 readline.read_history_file
                 # windows sometimes raises something other than ImportError
             except Exception:
                 pass
         line = raw_input(prompt)
         # When stdin is in binary mode on Windows, it can cause
         # raw_input() to emit an extra trailing carriage return
         if os.linesep == '\r\n' and line and line[-1] == '\r':
             line = line[:-1]
         return line
 
     def prompt(self, msg, pat=None, default="y"):
         """Prompt user with msg, read response, and ensure it matches pat
 
         If not interactive -- the default is returned
         """
         if not self.interactive:
             self.note(msg, ' ', default, "\n")
             return default
         while True:
             try:
                 r = self._readline(msg + ' ')
                 if not r:
                     return default
                 if not pat or re.match(pat, r):
                     return r
                 else:
                     self.write(_("unrecognized response\n"))
             except EOFError:
                 raise util.Abort(_('response expected'))
 
     def getpass(self, prompt=None, default=None):
         if not self.interactive: return default
         try:
             return getpass.getpass(prompt or _('password: '))
         except EOFError:
             raise util.Abort(_('response expected'))
     def status(self, *msg):
         if not self.quiet: self.write(*msg)
     def warn(self, *msg):
         self.write_err(*msg)
     def note(self, *msg):
         if self.verbose: self.write(*msg)
     def debug(self, *msg):
         if self.debugflag: self.write(*msg)
     def edit(self, text, user):
         (fd, name) = tempfile.mkstemp(prefix="hg-editor-", suffix=".txt",
                                       text=True)
         try:
             f = os.fdopen(fd, "w")
             f.write(text)
             f.close()
 
             editor = self.geteditor()
 
             util.system("%s \"%s\"" % (editor, name),
                         environ={'HGUSER': user},
                         onerr=util.Abort, errprefix=_("edit failed"))
 
             f = open(name)
             t = f.read()
             f.close()
             t = re.sub("(?m)^HG:.*\n", "", t)
         finally:
             os.unlink(name)
 
         return t
 
     def print_exc(self):
         '''print exception traceback if traceback printing enabled.
         only to call in exception handler. returns true if traceback
         printed.'''
         if self.traceback:
             traceback.print_exc()
         return self.traceback
 
     def geteditor(self):
         '''return editor to use'''
         return (os.environ.get("HGEDITOR") or
                 self.config("ui", "editor") or
                 os.environ.get("VISUAL") or
                 os.environ.get("EDITOR", "vi"))

tests/test-acl.out

@@ -1,587 +1,587 b''
 3:911600dab2ae
 requesting all changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 3 changes to 3 files
 updating working directory
 3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Extension disabled for lack of a hook
 Pushing as user fred
 hgrc = """
 """
 pushing to ../b
 searching for changes
 common changesets up to 6675d58eff77
 3 changesets found
 list of changesets:
 ef1ea85a6374b77d6da9dcda9541f498f2d17df7
 f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
 911600dab2ae7a9baff75958b84fe606851ce955
 adding changesets
 add changeset ef1ea85a6374
 add changeset f9cafe1212c8
 add changeset 911600dab2ae
 adding manifests
 adding file changes
 adding foo/Bar/file.txt revisions
 adding foo/file.txt revisions
 adding quux/file.py revisions
 added 3 changesets with 3 changes to 3 files
 updating the branch cache
 rolling back last transaction
 0:6675d58eff77
 
 Extension disabled for lack of acl.sources
 Pushing as user fred
 hgrc = """
 [hooks]
 pretxnchangegroup.acl = python:hgext.acl.hook
 """
 pushing to ../b
 searching for changes
 common changesets up to 6675d58eff77
 3 changesets found
 list of changesets:
 ef1ea85a6374b77d6da9dcda9541f498f2d17df7
 f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
 911600dab2ae7a9baff75958b84fe606851ce955
 adding changesets
 add changeset ef1ea85a6374
 add changeset f9cafe1212c8
 add changeset 911600dab2ae
 adding manifests
 adding file changes
 adding foo/Bar/file.txt revisions
 adding foo/file.txt revisions
 adding quux/file.py revisions
 added 3 changesets with 3 changes to 3 files
 calling hook pretxnchangegroup.acl: hgext.acl.hook
 acl: changes have source "push" - skipping
 updating the branch cache
 rolling back last transaction
 0:6675d58eff77
 
 No [acl.allow]/[acl.deny]
 Pushing as user fred
 hgrc = """
 [hooks]
 pretxnchangegroup.acl = python:hgext.acl.hook
 [acl]
 sources = push
 """
 pushing to ../b
 searching for changes
 common changesets up to 6675d58eff77
 3 changesets found
 list of changesets:
 ef1ea85a6374b77d6da9dcda9541f498f2d17df7
 f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
 911600dab2ae7a9baff75958b84fe606851ce955
 adding changesets
 add changeset ef1ea85a6374
 add changeset f9cafe1212c8
 add changeset 911600dab2ae
 adding manifests
 adding file changes
 adding foo/Bar/file.txt revisions
 adding foo/file.txt revisions
 adding quux/file.py revisions
 added 3 changesets with 3 changes to 3 files
 calling hook pretxnchangegroup.acl: hgext.acl.hook
 acl: acl.allow not enabled
 acl: acl.deny not enabled
 acl: allowing changeset ef1ea85a6374
 acl: allowing changeset f9cafe1212c8
 acl: allowing changeset 911600dab2ae
 updating the branch cache
 rolling back last transaction
 0:6675d58eff77
 
 Empty [acl.allow]
 Pushing as user fred
 hgrc = """
 [hooks]
 pretxnchangegroup.acl = python:hgext.acl.hook
 [acl]
 sources = push
 [acl.allow]
 """
 pushing to ../b
 searching for changes
 common changesets up to 6675d58eff77
 3 changesets found
 list of changesets:
 ef1ea85a6374b77d6da9dcda9541f498f2d17df7
 f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
 911600dab2ae7a9baff75958b84fe606851ce955
 adding changesets
 add changeset ef1ea85a6374
 add changeset f9cafe1212c8
 add changeset 911600dab2ae
 adding manifests
 adding file changes
 adding foo/Bar/file.txt revisions
 adding foo/file.txt revisions
 adding quux/file.py revisions
 added 3 changesets with 3 changes to 3 files
 calling hook pretxnchangegroup.acl: hgext.acl.hook
 acl: acl.allow enabled, 0 entries for user fred
 acl: acl.deny not enabled
 acl: user fred not allowed on foo/file.txt
 error: pretxnchangegroup.acl hook failed: acl: access denied for changeset ef1ea85a6374
 transaction abort!
 rollback completed
 abort: acl: access denied for changeset ef1ea85a6374
 no rollback information available
 0:6675d58eff77
 
 fred is allowed inside foo/
 Pushing as user fred
 hgrc = """
 [hooks]
 pretxnchangegroup.acl = python:hgext.acl.hook
 [acl]
 sources = push
 [acl.allow]
 foo/** = fred
 """
 pushing to ../b
 searching for changes
 common changesets up to 6675d58eff77
 3 changesets found
 list of changesets:
 ef1ea85a6374b77d6da9dcda9541f498f2d17df7
 f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
 911600dab2ae7a9baff75958b84fe606851ce955
 adding changesets
 add changeset ef1ea85a6374
 add changeset f9cafe1212c8
 add changeset 911600dab2ae
 adding manifests
 adding file changes
 adding foo/Bar/file.txt revisions
 adding foo/file.txt revisions
 adding quux/file.py revisions
 added 3 changesets with 3 changes to 3 files
 calling hook pretxnchangegroup.acl: hgext.acl.hook
 acl: acl.allow enabled, 1 entries for user fred
 acl: acl.deny not enabled
 acl: allowing changeset ef1ea85a6374
 acl: allowing changeset f9cafe1212c8
 acl: user fred not allowed on quux/file.py
 error: pretxnchangegroup.acl hook failed: acl: access denied for changeset 911600dab2ae
 transaction abort!
 rollback completed
 abort: acl: access denied for changeset 911600dab2ae
 no rollback information available
 0:6675d58eff77
 
 Empty [acl.deny]
 Pushing as user barney
 hgrc = """
 [hooks]
 pretxnchangegroup.acl = python:hgext.acl.hook
 [acl]
 sources = push
 [acl.allow]
 foo/** = fred
 [acl.deny]
 """
 pushing to ../b
 searching for changes
 common changesets up to 6675d58eff77
 3 changesets found
 list of changesets:
 ef1ea85a6374b77d6da9dcda9541f498f2d17df7
 f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
 911600dab2ae7a9baff75958b84fe606851ce955
 adding changesets
 add changeset ef1ea85a6374
 add changeset f9cafe1212c8
 add changeset 911600dab2ae
 adding manifests
 adding file changes
 adding foo/Bar/file.txt revisions
 adding foo/file.txt revisions
 adding quux/file.py revisions
 added 3 changesets with 3 changes to 3 files
 calling hook pretxnchangegroup.acl: hgext.acl.hook
 acl: acl.allow enabled, 0 entries for user barney
 acl: acl.deny enabled, 0 entries for user barney
 acl: user barney not allowed on foo/file.txt
 error: pretxnchangegroup.acl hook failed: acl: access denied for changeset ef1ea85a6374
 transaction abort!
 rollback completed
 abort: acl: access denied for changeset ef1ea85a6374
 no rollback information available
 0:6675d58eff77
 
 fred is allowed inside foo/, but not foo/bar/ (case matters)
 Pushing as user fred
 hgrc = """
 [hooks]
 pretxnchangegroup.acl = python:hgext.acl.hook
 [acl]
 sources = push
 [acl.allow]
 foo/** = fred
 [acl.deny]
 foo/bar/** = fred
 """
 pushing to ../b
 searching for changes
 common changesets up to 6675d58eff77
 3 changesets found
 list of changesets:
 ef1ea85a6374b77d6da9dcda9541f498f2d17df7
 f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
 911600dab2ae7a9baff75958b84fe606851ce955
 adding changesets
 add changeset ef1ea85a6374
 add changeset f9cafe1212c8
 add changeset 911600dab2ae
 adding manifests
 adding file changes
 adding foo/Bar/file.txt revisions
 adding foo/file.txt revisions
 adding quux/file.py revisions
 added 3 changesets with 3 changes to 3 files
 calling hook pretxnchangegroup.acl: hgext.acl.hook
 acl: acl.allow enabled, 1 entries for user fred
 acl: acl.deny enabled, 1 entries for user fred
 acl: allowing changeset ef1ea85a6374
 acl: allowing changeset f9cafe1212c8
 acl: user fred not allowed on quux/file.py
 error: pretxnchangegroup.acl hook failed: acl: access denied for changeset 911600dab2ae
 transaction abort!
 rollback completed
 abort: acl: access denied for changeset 911600dab2ae
 no rollback information available
 0:6675d58eff77
 
 fred is allowed inside foo/, but not foo/Bar/
 Pushing as user fred
 hgrc = """
 [hooks]
 pretxnchangegroup.acl = python:hgext.acl.hook
 [acl]
 sources = push
 [acl.allow]
 foo/** = fred
 [acl.deny]
 foo/bar/** = fred
 foo/Bar/** = fred
 """
 pushing to ../b
 searching for changes
 common changesets up to 6675d58eff77
 3 changesets found
 list of changesets:
 ef1ea85a6374b77d6da9dcda9541f498f2d17df7
 f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
 911600dab2ae7a9baff75958b84fe606851ce955
 adding changesets
 add changeset ef1ea85a6374
 add changeset f9cafe1212c8
 add changeset 911600dab2ae
 adding manifests
 adding file changes
 adding foo/Bar/file.txt revisions
 adding foo/file.txt revisions
 adding quux/file.py revisions
 added 3 changesets with 3 changes to 3 files
 calling hook pretxnchangegroup.acl: hgext.acl.hook
 acl: acl.allow enabled, 1 entries for user fred
 acl: acl.deny enabled, 2 entries for user fred
 acl: allowing changeset ef1ea85a6374
 acl: user fred denied on foo/Bar/file.txt
 error: pretxnchangegroup.acl hook failed: acl: access denied for changeset f9cafe1212c8
 transaction abort!
 rollback completed
 abort: acl: access denied for changeset f9cafe1212c8
 no rollback information available
 0:6675d58eff77
 
 barney is not mentioned => not allowed anywhere
 Pushing as user barney
 hgrc = """
 [hooks]
 pretxnchangegroup.acl = python:hgext.acl.hook
 [acl]
 sources = push
 [acl.allow]
 foo/** = fred
 [acl.deny]
 foo/bar/** = fred
 foo/Bar/** = fred
 """
 pushing to ../b
 searching for changes
 common changesets up to 6675d58eff77
 3 changesets found
 list of changesets:
 ef1ea85a6374b77d6da9dcda9541f498f2d17df7
 f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
 911600dab2ae7a9baff75958b84fe606851ce955
 adding changesets
 add changeset ef1ea85a6374
 add changeset f9cafe1212c8
 add changeset 911600dab2ae
 adding manifests
 adding file changes
 adding foo/Bar/file.txt revisions
 adding foo/file.txt revisions
 adding quux/file.py revisions
 added 3 changesets with 3 changes to 3 files
 calling hook pretxnchangegroup.acl: hgext.acl.hook
 acl: acl.allow enabled, 0 entries for user barney
 acl: acl.deny enabled, 0 entries for user barney
 acl: user barney not allowed on foo/file.txt
 error: pretxnchangegroup.acl hook failed: acl: access denied for changeset ef1ea85a6374
 transaction abort!
 rollback completed
 abort: acl: access denied for changeset ef1ea85a6374
 no rollback information available
 0:6675d58eff77
 
 barney is allowed everywhere
 Pushing as user barney
 hgrc = """
 [hooks]
 pretxnchangegroup.acl = python:hgext.acl.hook
 [acl]
 sources = push
 [acl.allow]
 foo/** = fred
 [acl.deny]
 foo/bar/** = fred
 foo/Bar/** = fred
 [acl.allow]
 ** = barney
 """
 pushing to ../b
 searching for changes
 common changesets up to 6675d58eff77
 3 changesets found
 list of changesets:
 ef1ea85a6374b77d6da9dcda9541f498f2d17df7
 f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
 911600dab2ae7a9baff75958b84fe606851ce955
 adding changesets
 add changeset ef1ea85a6374
 add changeset f9cafe1212c8
 add changeset 911600dab2ae
 adding manifests
 adding file changes
 adding foo/Bar/file.txt revisions
 adding foo/file.txt revisions
 adding quux/file.py revisions
 added 3 changesets with 3 changes to 3 files
 calling hook pretxnchangegroup.acl: hgext.acl.hook
 acl: acl.allow enabled, 1 entries for user barney
 acl: acl.deny enabled, 0 entries for user barney
 acl: allowing changeset ef1ea85a6374
 acl: allowing changeset f9cafe1212c8
 acl: allowing changeset 911600dab2ae
 updating the branch cache
 rolling back last transaction
 0:6675d58eff77
 
 wilma can change files with a .txt extension
 Pushing as user wilma
 hgrc = """
 [hooks]
 pretxnchangegroup.acl = python:hgext.acl.hook
 [acl]
 sources = push
 [acl.allow]
 foo/** = fred
 [acl.deny]
 foo/bar/** = fred
 foo/Bar/** = fred
 [acl.allow]
 ** = barney
 **/*.txt = wilma
 """
 pushing to ../b
 searching for changes
 common changesets up to 6675d58eff77
 3 changesets found
 list of changesets:
 ef1ea85a6374b77d6da9dcda9541f498f2d17df7
 f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
 911600dab2ae7a9baff75958b84fe606851ce955
 adding changesets
 add changeset ef1ea85a6374
 add changeset f9cafe1212c8
 add changeset 911600dab2ae
 adding manifests
 adding file changes
 adding foo/Bar/file.txt revisions
 adding foo/file.txt revisions
 adding quux/file.py revisions
 added 3 changesets with 3 changes to 3 files
 calling hook pretxnchangegroup.acl: hgext.acl.hook
 acl: acl.allow enabled, 1 entries for user wilma
 acl: acl.deny enabled, 0 entries for user wilma
 acl: allowing changeset ef1ea85a6374
 acl: allowing changeset f9cafe1212c8
 acl: user wilma not allowed on quux/file.py
 error: pretxnchangegroup.acl hook failed: acl: access denied for changeset 911600dab2ae
 transaction abort!
 rollback completed
 abort: acl: access denied for changeset 911600dab2ae
 no rollback information available
 0:6675d58eff77
 
 file specified by acl.config does not exist
 Pushing as user barney
 hgrc = """
 [hooks]
 pretxnchangegroup.acl = python:hgext.acl.hook
 [acl]
 sources = push
 [acl.allow]
 foo/** = fred
 [acl.deny]
 foo/bar/** = fred
 foo/Bar/** = fred
 [acl.allow]
 ** = barney
 **/*.txt = wilma
 [acl]
 config = ../acl.config
 """
 pushing to ../b
 searching for changes
 common changesets up to 6675d58eff77
 3 changesets found
 list of changesets:
 ef1ea85a6374b77d6da9dcda9541f498f2d17df7
 f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
 911600dab2ae7a9baff75958b84fe606851ce955
 adding changesets
 add changeset ef1ea85a6374
 add changeset f9cafe1212c8
 add changeset 911600dab2ae
 adding manifests
 adding file changes
 adding foo/Bar/file.txt revisions
 adding foo/file.txt revisions
 adding quux/file.py revisions
 added 3 changesets with 3 changes to 3 files
 calling hook pretxnchangegroup.acl: hgext.acl.hook
-error: pretxnchangegroup.acl hook failed: unable to open ../acl.config: No such file or directory
+error: pretxnchangegroup.acl hook raised an exception: [Errno 2] No such file or directory: '../acl.config'
 transaction abort!
 rollback completed
-abort: unable to open ../acl.config: No such file or directory
+abort: No such file or directory: ../acl.config
 no rollback information available
 0:6675d58eff77
 
 betty is allowed inside foo/ by a acl.config file
 Pushing as user betty
 hgrc = """
 [hooks]
 pretxnchangegroup.acl = python:hgext.acl.hook
 [acl]
 sources = push
 [acl.allow]
 foo/** = fred
 [acl.deny]
 foo/bar/** = fred
 foo/Bar/** = fred
 [acl.allow]
 ** = barney
 **/*.txt = wilma
 [acl]
 config = ../acl.config
 """
 acl.config = """
 [acl.allow]
 foo/** = betty
 """
 pushing to ../b
 searching for changes
 common changesets up to 6675d58eff77
 3 changesets found
 list of changesets:
 ef1ea85a6374b77d6da9dcda9541f498f2d17df7
 f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
 911600dab2ae7a9baff75958b84fe606851ce955
 adding changesets
 add changeset ef1ea85a6374
 add changeset f9cafe1212c8
 add changeset 911600dab2ae
 adding manifests
 adding file changes
 adding foo/Bar/file.txt revisions
 adding foo/file.txt revisions
 adding quux/file.py revisions
 added 3 changesets with 3 changes to 3 files
 calling hook pretxnchangegroup.acl: hgext.acl.hook
 acl: acl.allow enabled, 1 entries for user betty
 acl: acl.deny enabled, 0 entries for user betty
 acl: allowing changeset ef1ea85a6374
 acl: allowing changeset f9cafe1212c8
 acl: user betty not allowed on quux/file.py
 error: pretxnchangegroup.acl hook failed: acl: access denied for changeset 911600dab2ae
 transaction abort!
 rollback completed
 abort: acl: access denied for changeset 911600dab2ae
 no rollback information available
 0:6675d58eff77
 
 acl.config can set only [acl.allow]/[acl.deny]
 Pushing as user barney
 hgrc = """
 [hooks]
 pretxnchangegroup.acl = python:hgext.acl.hook
 [acl]
 sources = push
 [acl.allow]
 foo/** = fred
 [acl.deny]
 foo/bar/** = fred
 foo/Bar/** = fred
 [acl.allow]
 ** = barney
 **/*.txt = wilma
 [acl]
 config = ../acl.config
 """
 acl.config = """
 [acl.allow]
 foo/** = betty
 [hooks]
 changegroup.acl = false
 """
 pushing to ../b
 searching for changes
 common changesets up to 6675d58eff77
 3 changesets found
 list of changesets:
 ef1ea85a6374b77d6da9dcda9541f498f2d17df7
 f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
 911600dab2ae7a9baff75958b84fe606851ce955
 adding changesets
 add changeset ef1ea85a6374
 add changeset f9cafe1212c8
 add changeset 911600dab2ae
 adding manifests
 adding file changes
 adding foo/Bar/file.txt revisions
 adding foo/file.txt revisions
 adding quux/file.py revisions
 added 3 changesets with 3 changes to 3 files
 calling hook pretxnchangegroup.acl: hgext.acl.hook
 acl: acl.allow enabled, 1 entries for user barney
 acl: acl.deny enabled, 0 entries for user barney
 acl: allowing changeset ef1ea85a6374
 acl: allowing changeset f9cafe1212c8
 acl: allowing changeset 911600dab2ae
 updating the branch cache
 rolling back last transaction
 0:6675d58eff77
 

tests/test-notify

@@ -1,100 +1,100 b''
 #!/bin/sh
 
 cat <<EOF >> $HGRCPATH
 [extensions]
 notify=
 
 [hooks]
 incoming.notify = python:hgext.notify.hook
 
 [notify]
 sources = pull
 diffstat = False
 
 [usersubs]
 foo@bar = *
 
 [reposubs]
 * = baz
 EOF
 
 hg help notify
 hg init a
 echo a > a/a
 echo % commit
 hg --traceback --cwd a commit -Ama -d '0 0'
 
 echo % clone
 hg --traceback clone a b
 
 echo a >> a/a
 echo % commit
 hg --traceback --cwd a commit -Amb -d '1 0'
 
 # on Mac OS X 10.5 the tmp path is very long so would get stripped in the subject line
 cat <<EOF >> $HGRCPATH
 [notify]
 maxsubject = 200
 EOF
 
 # the python call below wraps continuation lines, which appear on Mac OS X 10.5 because
 # of the very long subject line
 echo '% pull (minimal config)'
 hg --traceback --cwd b pull ../a 2>&1 |
   python -c 'import sys,re; print re.sub("\n\t", " ", sys.stdin.read()),' |
   sed -e 's/\(Message-Id:\).*/\1/' \
   -e 's/changeset \([0-9a-f]* *\)in .*test-notif/changeset \1in test-notif/' \
   -e 's/^details: .*test-notify/details: test-notify/' \
   -e 's/^Date:.*/Date:/'
 
 cat <<EOF >> $HGRCPATH
 [notify]
 config = $HGTMP/.notify.conf
 domain = test.com
 strip = 3
 template = Subject: {desc|firstline|strip}\nFrom: {author}\nX-Test: foo\n\nchangeset {node|short} in {webroot}\ndescription:\n\t{desc|tabindent|strip}
 
 [web]
 baseurl = http://test/
 EOF
 
 echo % fail for config file is missing
 hg --cwd b rollback
-hg --cwd b pull ../a 2>&1 | grep 'unable to open.*\.notify\.conf' > /dev/null && echo pull failed
+hg --cwd b pull ../a 2>&1 | grep 'error.*\.notify\.conf' > /dev/null && echo pull failed
 
 touch "$HGTMP/.notify.conf"
 
 echo % pull
 hg --cwd b rollback
 hg --traceback --cwd b pull ../a 2>&1 | sed -e 's/\(Message-Id:\).*/\1/' \
   -e 's/changeset \([0-9a-f]*\) in .*/changeset \1/' \
   -e 's/^Date:.*/Date:/'
 
 cat << EOF >> $HGRCPATH
 [hooks]
 incoming.notify = python:hgext.notify.hook
 
 [notify]
 sources = pull
 diffstat = True
 EOF
 
 echo % pull
 hg --cwd b rollback
 hg --traceback --cwd b pull ../a 2>&1 | sed -e 's/\(Message-Id:\).*/\1/' \
   -e 's/changeset \([0-9a-f]*\) in .*/changeset \1/' \
   -e 's/^Date:.*/Date:/'
 
 echo % test merge
 cd a
 hg up -C 0
 echo a >> a
 hg ci -Am adda2 -d '2 0'
 hg merge
 hg ci -m merge -d '3 0'
 cd ..
 
 hg --traceback --cwd b pull ../a 2>&1 | sed -e 's/\(Message-Id:\).*/\1/' \
   -e 's/changeset \([0-9a-f]*\) in .*/changeset \1/' \
   -e 's/^Date:.*/Date:/'
 

tests/test-trusted.py

@@ -1,211 +1,211 b''
 # Since it's not easy to write a test that portably deals
 # with files from different users/groups, we cheat a bit by
 # monkey-patching some functions in the util module
 
 import os
 from mercurial import ui, util
 
 hgrc = os.environ['HGRCPATH']
 f = open(hgrc)
 basehgrc = f.read()
 f.close()
 
 def testui(user='foo', group='bar', tusers=(), tgroups=(),
            cuser='foo', cgroup='bar', debug=False, silent=False):
     # user, group => owners of the file
     # tusers, tgroups => trusted users/groups
     # cuser, cgroup => user/group of the current process
 
     # write a global hgrc with the list of trusted users/groups and
     # some setting so that we can be sure it was read
     f = open(hgrc, 'w')
     f.write(basehgrc)
     f.write('\n[paths]\n')
     f.write('global = /some/path\n\n')
 
     if tusers or tgroups:
         f.write('[trusted]\n')
         if tusers:
             f.write('users = %s\n' % ', '.join(tusers))
         if tgroups:
             f.write('groups = %s\n' % ', '.join(tgroups))
     f.close()
 
     # override the functions that give names to uids and gids
     def username(uid=None):
         if uid is None:
             return cuser
         return user
     util.username = username
 
     def groupname(gid=None):
         if gid is None:
             return 'bar'
         return group
     util.groupname = groupname
 
     def isowner(fp, st=None):
         return user == cuser
     util.isowner = isowner
 
     # try to read everything
     #print '# File belongs to user %s, group %s' % (user, group)
     #print '# trusted users = %s; trusted groups = %s' % (tusers, tgroups)
     kind = ('different', 'same')
     who = ('', 'user', 'group', 'user and the group')
     trusted = who[(user in tusers) + 2*(group in tgroups)]
     if trusted:
         trusted = ', but we trust the ' + trusted
     print '# %s user, %s group%s' % (kind[user == cuser], kind[group == cgroup],
                                      trusted)
 
     parentui = ui.ui()
     parentui.setconfig('ui', 'debug', str(bool(debug)))
     u = ui.ui(parentui=parentui)
     u.readconfig('.hg/hgrc')
     if silent:
         return u
     print 'trusted'
     for name, path in u.configitems('paths'):
         print '   ', name, '=', path
     print 'untrusted'
     for name, path in u.configitems('paths', untrusted=True):
         print '.',
         u.config('paths', name) # warning with debug=True
         print '.',
         u.config('paths', name, untrusted=True) # no warnings
         print name, '=', path
     print
 
     return u
 
 os.mkdir('repo')
 os.chdir('repo')
 os.mkdir('.hg')
 f = open('.hg/hgrc', 'w')
 f.write('[paths]\n')
 f.write('local = /another/path\n\n')
 f.write('interpolated = %(global)s%(local)s\n\n')
 f.close()
 
 #print '# Everything is run by user foo, group bar\n'
 
 # same user, same group
 testui()
 # same user, different group
 testui(group='def')
 # different user, same group
 testui(user='abc')
 # ... but we trust the group
 testui(user='abc', tgroups=['bar'])
 # different user, different group
 testui(user='abc', group='def')
 # ... but we trust the user
 testui(user='abc', group='def', tusers=['abc'])
 # ... but we trust the group
 testui(user='abc', group='def', tgroups=['def'])
 # ... but we trust the user and the group
 testui(user='abc', group='def', tusers=['abc'], tgroups=['def'])
 # ... but we trust all users
 print '# we trust all users'
 testui(user='abc', group='def', tusers=['*'])
 # ... but we trust all groups
 print '# we trust all groups'
 testui(user='abc', group='def', tgroups=['*'])
 # ... but we trust the whole universe
 print '# we trust all users and groups'
 testui(user='abc', group='def', tusers=['*'], tgroups=['*'])
 # ... check that users and groups are in different namespaces
 print "# we don't get confused by users and groups with the same name"
 testui(user='abc', group='def', tusers=['def'], tgroups=['abc'])
 # ... lists of user names work
 print "# list of user names"
 testui(user='abc', group='def', tusers=['foo', 'xyz', 'abc', 'bleh'],
        tgroups=['bar', 'baz', 'qux'])
 # ... lists of group names work
 print "# list of group names"
 testui(user='abc', group='def', tusers=['foo', 'xyz', 'bleh'],
        tgroups=['bar', 'def', 'baz', 'qux'])
 
 print "# Can't figure out the name of the user running this process"
 testui(user='abc', group='def', cuser=None)
 
 print "# prints debug warnings"
 u = testui(user='abc', group='def', cuser='foo', debug=True)
 
-print "# ui.readsections"
+print "# ui.readconfig sections"
 filename = 'foobar'
 f = open(filename, 'w')
 f.write('[foobar]\n')
 f.write('baz = quux\n')
 f.close()
-u.readsections(filename, 'foobar')
+u.readconfig(filename, sections = ['foobar'])
 print u.config('foobar', 'baz')
 
 print
 print "# read trusted, untrusted, new ui, trusted"
 u = ui.ui()
 u.setconfig('ui', 'debug', 'on')
 u.readconfig(filename)
 u2 = ui.ui(parentui=u)
 def username(uid=None):
     return 'foo'
 util.username = username
 u2.readconfig('.hg/hgrc')
 print 'trusted:'
 print u2.config('foobar', 'baz')
 print u2.config('paths', 'interpolated')
 print 'untrusted:'
 print u2.config('foobar', 'baz', untrusted=True)
 print u2.config('paths', 'interpolated', untrusted=True)
 
 print
 print "# error handling"
 
 def assertraises(f, exc=util.Abort):
     try:
         f()
     except exc, inst:
         print 'raised', inst.__class__.__name__
     else:
         print 'no exception?!'
 
 print "# file doesn't exist"
 os.unlink('.hg/hgrc')
 assert not os.path.exists('.hg/hgrc')
 testui(debug=True, silent=True)
 testui(user='abc', group='def', debug=True, silent=True)
 
 print
 print "# parse error"
 f = open('.hg/hgrc', 'w')
 f.write('foo = bar')
 f.close()
 testui(user='abc', group='def', silent=True)
 assertraises(lambda: testui(debug=True, silent=True))
 
 print
 print "# interpolation error"
 f = open('.hg/hgrc', 'w')
 f.write('[foo]\n')
 f.write('bar = %(')
 f.close()
 u = testui(debug=True, silent=True)
 print '# regular config:'
 print '  trusted',
 assertraises(lambda: u.config('foo', 'bar'))
 print 'untrusted',
 assertraises(lambda: u.config('foo', 'bar', untrusted=True))
 
 u = testui(user='abc', group='def', debug=True, silent=True)
 print '  trusted ',
 print u.config('foo', 'bar')
 print 'untrusted',
 assertraises(lambda: u.config('foo', 'bar', untrusted=True))
 
 print '# configitems:'
 print '  trusted ',
 print u.configitems('foo')
 print 'untrusted',
 assertraises(lambda: u.configitems('foo', untrusted=True))
 

tests/test-trusted.py.out

@@ -1,211 +1,211 b''
 # same user, same group
 trusted
     global = /some/path
     interpolated = /some/path/another/path
     local = /another/path
 untrusted
 . . global = /some/path
 . . interpolated = /some/path/another/path
 . . local = /another/path
 
 # same user, different group
 trusted
     global = /some/path
     interpolated = /some/path/another/path
     local = /another/path
 untrusted
 . . global = /some/path
 . . interpolated = /some/path/another/path
 . . local = /another/path
 
 # different user, same group
 Not trusting file .hg/hgrc from untrusted user abc, group bar
 trusted
     global = /some/path
 untrusted
 . . global = /some/path
 . . interpolated = /some/path/another/path
 . . local = /another/path
 
 # different user, same group, but we trust the group
 trusted
     global = /some/path
     interpolated = /some/path/another/path
     local = /another/path
 untrusted
 . . global = /some/path
 . . interpolated = /some/path/another/path
 . . local = /another/path
 
 # different user, different group
 Not trusting file .hg/hgrc from untrusted user abc, group def
 trusted
     global = /some/path
 untrusted
 . . global = /some/path
 . . interpolated = /some/path/another/path
 . . local = /another/path
 
 # different user, different group, but we trust the user
 trusted
     global = /some/path
     interpolated = /some/path/another/path
     local = /another/path
 untrusted
 . . global = /some/path
 . . interpolated = /some/path/another/path
 . . local = /another/path
 
 # different user, different group, but we trust the group
 trusted
     global = /some/path
     interpolated = /some/path/another/path
     local = /another/path
 untrusted
 . . global = /some/path
 . . interpolated = /some/path/another/path
 . . local = /another/path
 
 # different user, different group, but we trust the user and the group
 trusted
     global = /some/path
     interpolated = /some/path/another/path
     local = /another/path
 untrusted
 . . global = /some/path
 . . interpolated = /some/path/another/path
 . . local = /another/path
 
 # we trust all users
 # different user, different group
 trusted
     global = /some/path
     interpolated = /some/path/another/path
     local = /another/path
 untrusted
 . . global = /some/path
 . . interpolated = /some/path/another/path
 . . local = /another/path
 
 # we trust all groups
 # different user, different group
 trusted
     global = /some/path
     interpolated = /some/path/another/path
     local = /another/path
 untrusted
 . . global = /some/path
 . . interpolated = /some/path/another/path
 . . local = /another/path
 
 # we trust all users and groups
 # different user, different group
 trusted
     global = /some/path
     interpolated = /some/path/another/path
     local = /another/path
 untrusted
 . . global = /some/path
 . . interpolated = /some/path/another/path
 . . local = /another/path
 
 # we don't get confused by users and groups with the same name
 # different user, different group
 Not trusting file .hg/hgrc from untrusted user abc, group def
 trusted
     global = /some/path
 untrusted
 . . global = /some/path
 . . interpolated = /some/path/another/path
 . . local = /another/path
 
 # list of user names
 # different user, different group, but we trust the user
 trusted
     global = /some/path
     interpolated = /some/path/another/path
     local = /another/path
 untrusted
 . . global = /some/path
 . . interpolated = /some/path/another/path
 . . local = /another/path
 
 # list of group names
 # different user, different group, but we trust the group
 trusted
     global = /some/path
     interpolated = /some/path/another/path
     local = /another/path
 untrusted
 . . global = /some/path
 . . interpolated = /some/path/another/path
 . . local = /another/path
 
 # Can't figure out the name of the user running this process
 # different user, different group
 Not trusting file .hg/hgrc from untrusted user abc, group def
 trusted
     global = /some/path
 untrusted
 . . global = /some/path
 . . interpolated = /some/path/another/path
 . . local = /another/path
 
 # prints debug warnings
 # different user, different group
 Not trusting file .hg/hgrc from untrusted user abc, group def
 trusted
 Ignoring untrusted configuration option paths.interpolated = /some/path/another/path
 Ignoring untrusted configuration option paths.local = /another/path
     global = /some/path
 untrusted
 . . global = /some/path
 .Ignoring untrusted configuration option paths.interpolated = /some/path/another/path
  . interpolated = /some/path/another/path
 .Ignoring untrusted configuration option paths.local = /another/path
  . local = /another/path
 
-# ui.readsections
+# ui.readconfig sections
 quux
 
 # read trusted, untrusted, new ui, trusted
 Not trusting file foobar from untrusted user abc, group def
 trusted:
 Ignoring untrusted configuration option foobar.baz = quux
 None
 /some/path/another/path
 untrusted:
 quux
 /some/path/another/path
 
 # error handling
 # file doesn't exist
 # same user, same group
 # different user, different group
 
 # parse error
 # different user, different group
 Not trusting file .hg/hgrc from untrusted user abc, group def
 Ignored: Failed to parse .hg/hgrc
 File contains no section headers.
 file: .hg/hgrc, line: 1
 'foo = bar'
 # same user, same group
 raised Abort
 
 # interpolation error
 # same user, same group
 # regular config:
   trusted raised Abort
 untrusted raised Abort
 # different user, different group
 Not trusting file .hg/hgrc from untrusted user abc, group def
   trusted Ignored: Error in configuration section [foo] parameter 'bar':
 bad interpolation variable reference '%('
  None
 untrusted raised Abort
 # configitems:
   trusted Ignored: Error in configuration section [foo]:
 bad interpolation variable reference '%('
  []
 untrusted raised Abort