ui: introduce new config parser

mercurial/config.py

@@ -0,0 +1,93 b''
+from i18n import _
+import re, error
+
+class sortdict(dict):
+    'a simple append-only sorted dictionary'
+    def __init__(self, data=None):
+        self._list = []
+        if data:
+            if hasattr(data, '_list'):
+                self._list = list(data._list)
+            self.update(data)
+    def copy(self):
+        return sortdict(self)
+    def __setitem__(self, key, val):
+        if key in self:
+            self._list.remove(key)
+        self._list.append(key)
+        dict.__setitem__(self, key, val)
+    def __iter__(self):
+        return self._list.__iter__()
+    def update(self, src):
+        for k in src:
+            self[k] = src[k]
+    def items(self):
+        return [(k,self[k]) for k in self._list]
+
+class config:
+    def __init__(self, data=None):
+        self._data = {}
+        if data:
+            for k in data._data:
+                self._data[k] = data[k].copy()
+    def copy(self):
+        return config(self)
+    def __contains__(self, section):
+        return section in self._data
+    def update(self, src, sections=None):
+        if not sections:
+            sections = src.sections()
+        for s in sections:
+            if s not in src:
+                continue
+            if s not in self:
+                self._data[s] = sortdict()
+            for k in src._data[s]:
+                self._data[s][k] = src._data[s][k]
+    def get(self, section, item, default=None):
+        return self._data.get(section, {}).get(item, (default, ""))[0]
+    def getsource(self, section, item):
+        return self._data.get(section, {}).get(item, (None, ""))[1]
+    def sections(self):
+        return sorted(self._data.keys())
+    def items(self, section):
+        return [(k, v[0]) for k,v in self._data.get(section, {}).items()]
+    def set(self, section, item, value, source=""):
+        if section not in self:
+            self._data[section] = sortdict()
+        self._data[section][item] = (value, source)
+
+    def read(self, path, fp):
+        sectionre = re.compile(r'\[([^\[]+)\]')
+        itemre = re.compile(r'([^=\s]+)\s*=\s*(.*)')
+        contre = re.compile(r'\s+(\S.*)')
+        emptyre = re.compile(r'(;|#|\s*$)')
+        section = ""
+        item = None
+        line = 0
+        cont = 0
+        for l in fp:
+            line += 1
+            if cont:
+                m = contre.match(l)
+                if m:
+                    v = self.get(section, item) + "\n" + m.group(1)
+                    self.set(section, item, v, "%s:%d" % (path, line))
+                    continue
+                item = None
+            if emptyre.match(l):
+                continue
+            m = sectionre.match(l)
+            if m:
+                section = m.group(1)
+                if section not in self:
+                    self._data[section] = sortdict()
+                continue
+            m = itemre.match(l)
+            if m:
+                item = m.group(1)
+                self.set(section, item, m.group(2), "%s:%d" % (path, line))
+                cont = 1
+                continue
+            raise error.ConfigError(_('config error at %s:%d: \'%s\'')
+                                    % (path, line, l.rstrip()))

mercurial/dispatch.py

@@ -1,428 +1,430 b''
 # dispatch.py - command dispatching 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 os, sys, atexit, signal, pdb, socket, errno, shlex, time
 import util, commands, hg, fancyopts, extensions, hook, error
 import cmdutil, encoding
 import ui as _ui
 
 def run():
     "run the command in sys.argv"
     sys.exit(dispatch(sys.argv[1:]))
 
 def dispatch(args):
     "run the command specified in args"
     try:
         u = _ui.ui()
         if '--traceback' in args:
             u.setconfig('ui', 'traceback', 'on')
     except util.Abort, inst:
         sys.stderr.write(_("abort: %s\n") % inst)
         return -1
     return _runcatch(u, args)
 
 def _runcatch(ui, args):
     def catchterm(*args):
         raise error.SignalInterrupt
 
     for name in 'SIGBREAK', 'SIGHUP', 'SIGTERM':
         num = getattr(signal, name, None)
         if num: signal.signal(num, catchterm)
 
     try:
         try:
             # enter the debugger before command execution
             if '--debugger' in args:
                 pdb.set_trace()
             try:
                 return _dispatch(ui, args)
             finally:
                 ui.flush()
         except:
             # enter the debugger when we hit an exception
             if '--debugger' in args:
                 pdb.post_mortem(sys.exc_info()[2])
             ui.print_exc()
             raise
 
     # Global exception handling, alphabetically
     # Mercurial-specific first, followed by built-in and library exceptions
     except error.AmbiguousCommand, inst:
         ui.warn(_("hg: command '%s' is ambiguous:\n    %s\n") %
                 (inst.args[0], " ".join(inst.args[1])))
+    except error.ConfigError, inst:
+        ui.warn(_("hg: %s\n") % inst.args[0])
     except error.LockHeld, inst:
         if inst.errno == errno.ETIMEDOUT:
             reason = _('timed out waiting for lock held by %s') % inst.locker
         else:
             reason = _('lock held by %s') % inst.locker
         ui.warn(_("abort: %s: %s\n") % (inst.desc or inst.filename, reason))
     except error.LockUnavailable, inst:
         ui.warn(_("abort: could not lock %s: %s\n") %
                (inst.desc or inst.filename, inst.strerror))
     except error.ParseError, inst:
         if inst.args[0]:
             ui.warn(_("hg %s: %s\n") % (inst.args[0], inst.args[1]))
             commands.help_(ui, inst.args[0])
         else:
             ui.warn(_("hg: %s\n") % inst.args[1])
             commands.help_(ui, 'shortlist')
     except error.RepoError, inst:
         ui.warn(_("abort: %s!\n") % inst)
     except error.ResponseError, inst:
         ui.warn(_("abort: %s") % inst.args[0])
         if not isinstance(inst.args[1], basestring):
             ui.warn(" %r\n" % (inst.args[1],))
         elif not inst.args[1]:
             ui.warn(_(" empty string\n"))
         else:
             ui.warn("\n%r\n" % util.ellipsis(inst.args[1]))
     except error.RevlogError, inst:
         ui.warn(_("abort: %s!\n") % inst)
     except error.SignalInterrupt:
         ui.warn(_("killed!\n"))
     except error.UnknownCommand, inst:
         ui.warn(_("hg: unknown command '%s'\n") % inst.args[0])
         commands.help_(ui, 'shortlist')
     except util.Abort, inst:
         ui.warn(_("abort: %s\n") % inst)
     except ImportError, inst:
         m = str(inst).split()[-1]
         ui.warn(_("abort: could not import module %s!\n") % m)
         if m in "mpatch bdiff".split():
             ui.warn(_("(did you forget to compile extensions?)\n"))
         elif m in "zlib".split():
             ui.warn(_("(is your Python install correct?)\n"))
     except IOError, inst:
         if hasattr(inst, "code"):
             ui.warn(_("abort: %s\n") % inst)
         elif hasattr(inst, "reason"):
             try: # usually it is in the form (errno, strerror)
                 reason = inst.reason.args[1]
             except: # it might be anything, for example a string
                 reason = inst.reason
             ui.warn(_("abort: error: %s\n") % reason)
         elif hasattr(inst, "args") and inst.args[0] == errno.EPIPE:
             if ui.debugflag:
                 ui.warn(_("broken pipe\n"))
         elif getattr(inst, "strerror", None):
             if getattr(inst, "filename", None):
                 ui.warn(_("abort: %s: %s\n") % (inst.strerror, inst.filename))
             else:
                 ui.warn(_("abort: %s\n") % inst.strerror)
         else:
             raise
     except OSError, inst:
         if getattr(inst, "filename", None):
             ui.warn(_("abort: %s: %s\n") % (inst.strerror, inst.filename))
         else:
             ui.warn(_("abort: %s\n") % inst.strerror)
     except KeyboardInterrupt:
         try:
             ui.warn(_("interrupted!\n"))
         except IOError, inst:
             if inst.errno == errno.EPIPE:
                 if ui.debugflag:
                     ui.warn(_("\nbroken pipe\n"))
             else:
                 raise
     except MemoryError:
         ui.warn(_("abort: out of memory\n"))
     except SystemExit, inst:
         # Commands shouldn't sys.exit directly, but give a return code.
         # Just in case catch this and and pass exit code to caller.
         return inst.code
     except socket.error, inst:
         ui.warn(_("abort: %s\n") % inst.args[-1])
     except:
         ui.warn(_("** unknown exception encountered, details follow\n"))
         ui.warn(_("** report bug details to "
                  "http://www.selenic.com/mercurial/bts\n"))
         ui.warn(_("** or [e-mail]\n"))
         ui.warn(_("** Mercurial Distributed SCM (version %s)\n")
                % util.version())
         ui.warn(_("** Extensions loaded: %s\n")
                % ", ".join([x[0] for x in extensions.extensions()]))
         raise
 
     return -1
 
 def _findrepo(p):
     while not os.path.isdir(os.path.join(p, ".hg")):
         oldp, p = p, os.path.dirname(p)
         if p == oldp:
             return None
 
     return p
 
 def _parse(ui, args):
     options = {}
     cmdoptions = {}
 
     try:
         args = fancyopts.fancyopts(args, commands.globalopts, options)
     except fancyopts.getopt.GetoptError, inst:
         raise error.ParseError(None, inst)
 
     if args:
         cmd, args = args[0], args[1:]
         aliases, i = cmdutil.findcmd(cmd, commands.table,
                                      ui.config("ui", "strict"))
         cmd = aliases[0]
         defaults = ui.config("defaults", cmd)
         if defaults:
             args = shlex.split(defaults) + args
         c = list(i[1])
     else:
         cmd = None
         c = []
 
     # combine global options into local
     for o in commands.globalopts:
         c.append((o[0], o[1], options[o[1]], o[3]))
 
     try:
         args = fancyopts.fancyopts(args, c, cmdoptions, True)
     except fancyopts.getopt.GetoptError, inst:
         raise error.ParseError(cmd, inst)
 
     # separate global options back out
     for o in commands.globalopts:
         n = o[1]
         options[n] = cmdoptions[n]
         del cmdoptions[n]
 
     return (cmd, cmd and i[0] or None, args, options, cmdoptions)
 
 def _parseconfig(ui, config):
     """parse the --config options from the command line"""
     for cfg in config:
         try:
             name, value = cfg.split('=', 1)
             section, name = name.split('.', 1)
             if not section or not name:
                 raise IndexError
             ui.setconfig(section, name, value)
         except (IndexError, ValueError):
             raise util.Abort(_('malformed --config option: %s') % cfg)
 
 def _earlygetopt(aliases, args):
     """Return list of values for an option (or aliases).
 
     The values are listed in the order they appear in args.
     The options and values are removed from args.
     """
     try:
         argcount = args.index("--")
     except ValueError:
         argcount = len(args)
     shortopts = [opt for opt in aliases if len(opt) == 2]
     values = []
     pos = 0
     while pos < argcount:
         if args[pos] in aliases:
             if pos + 1 >= argcount:
                 # ignore and let getopt report an error if there is no value
                 break
             del args[pos]
             values.append(args.pop(pos))
             argcount -= 2
         elif args[pos][:2] in shortopts:
             # short option can have no following space, e.g. hg log -Rfoo
             values.append(args.pop(pos)[2:])
             argcount -= 1
         else:
             pos += 1
     return values
 
 def runcommand(lui, repo, cmd, fullargs, ui, options, d):
     # run pre-hook, and abort if it fails
     ret = hook.hook(lui, repo, "pre-%s" % cmd, False, args=" ".join(fullargs))
     if ret:
         return ret
     ret = _runcommand(ui, options, cmd, d)
     # run post-hook, passing command result
     hook.hook(lui, repo, "post-%s" % cmd, False, args=" ".join(fullargs),
               result = ret)
     return ret
 
 _loaded = {}
 def _dispatch(ui, args):
     # read --config before doing anything else
     # (e.g. to change trust settings for reading .hg/hgrc)
     _parseconfig(ui, _earlygetopt(['--config'], args))
 
     # check for cwd
     cwd = _earlygetopt(['--cwd'], args)
     if cwd:
         os.chdir(cwd[-1])
 
     # read the local repository .hgrc into a local ui object
     path = _findrepo(os.getcwd()) or ""
     if not path:
         lui = ui
     if path:
         try:
             lui = _ui.ui(parentui=ui)
             lui.readconfig(os.path.join(path, ".hg", "hgrc"))
         except IOError:
             pass
 
     # now we can expand paths, even ones in .hg/hgrc
     rpath = _earlygetopt(["-R", "--repository", "--repo"], args)
     if rpath:
         path = lui.expandpath(rpath[-1])
         lui = _ui.ui(parentui=ui)
         lui.readconfig(os.path.join(path, ".hg", "hgrc"))
 
     extensions.loadall(lui)
     for name, module in extensions.extensions():
         if name in _loaded:
             continue
 
         # setup extensions
         # TODO this should be generalized to scheme, where extensions can
         #      redepend on other extensions.  then we should toposort them, and
         #      do initialization in correct order
         extsetup = getattr(module, 'extsetup', None)
         if extsetup:
             extsetup()
 
         cmdtable = getattr(module, 'cmdtable', {})
         overrides = [cmd for cmd in cmdtable if cmd in commands.table]
         if overrides:
             ui.warn(_("extension '%s' overrides commands: %s\n")
                     % (name, " ".join(overrides)))
         commands.table.update(cmdtable)
         _loaded[name] = 1
     # check for fallback encoding
     fallback = lui.config('ui', 'fallbackencoding')
     if fallback:
         encoding.fallbackencoding = fallback
 
     fullargs = args
     cmd, func, args, options, cmdoptions = _parse(lui, args)
 
     if options["config"]:
         raise util.Abort(_("Option --config may not be abbreviated!"))
     if options["cwd"]:
         raise util.Abort(_("Option --cwd may not be abbreviated!"))
     if options["repository"]:
         raise util.Abort(_(
             "Option -R has to be separated from other options (i.e. not -qR) "
             "and --repository may only be abbreviated as --repo!"))
 
     if options["encoding"]:
         encoding.encoding = options["encoding"]
     if options["encodingmode"]:
         encoding.encodingmode = options["encodingmode"]
     if options["time"]:
         def get_times():
             t = os.times()
             if t[4] == 0.0: # Windows leaves this as zero, so use time.clock()
                 t = (t[0], t[1], t[2], t[3], time.clock())
             return t
         s = get_times()
         def print_time():
             t = get_times()
             ui.warn(_("Time: real %.3f secs (user %.3f+%.3f sys %.3f+%.3f)\n") %
                 (t[4]-s[4], t[0]-s[0], t[2]-s[2], t[1]-s[1], t[3]-s[3]))
         atexit.register(print_time)
 
     if options['verbose'] or options['debug'] or options['quiet']:
         ui.setconfig('ui', 'verbose', str(bool(options['verbose'])))
         ui.setconfig('ui', 'debug', str(bool(options['debug'])))
         ui.setconfig('ui', 'quiet', str(bool(options['quiet'])))
     if options['traceback']:
         ui.setconfig('ui', 'traceback', 'on')
     if options['noninteractive']:
         ui.setconfig('ui', 'interactive', 'off')
 
     if options['help']:
         return commands.help_(ui, cmd, options['version'])
     elif options['version']:
         return commands.version_(ui)
     elif not cmd:
         return commands.help_(ui, 'shortlist')
 
     repo = None
     if cmd not in commands.norepo.split():
         try:
             repo = hg.repository(ui, path=path)
             ui = repo.ui
             if not repo.local():
                 raise util.Abort(_("repository '%s' is not local") % path)
             ui.setconfig("bundle", "mainreporoot", repo.root)
         except error.RepoError:
             if cmd not in commands.optionalrepo.split():
                 if args and not path: # try to infer -R from command args
                     repos = map(_findrepo, args)
                     guess = repos[0]
                     if guess and repos.count(guess) == len(repos):
                         return _dispatch(ui, ['--repository', guess] + fullargs)
                 if not path:
                     raise error.RepoError(_("There is no Mercurial repository"
                                       " here (.hg not found)"))
                 raise
         args.insert(0, repo)
     elif rpath:
         ui.warn("warning: --repository ignored\n")
 
     d = lambda: util.checksignature(func)(ui, *args, **cmdoptions)
     return runcommand(lui, repo, cmd, fullargs, ui, options, d)
 
 def _runcommand(ui, options, cmd, cmdfunc):
     def checkargs():
         try:
             return cmdfunc()
         except error.SignatureError:
             raise error.ParseError(cmd, _("invalid arguments"))
 
     if options['profile']:
         format = ui.config('profiling', 'format', default='text')
 
         if not format in ['text', 'kcachegrind']:
             ui.warn(_("unrecognized profiling format '%s'"
                         " - Ignored\n") % format)
             format = 'text'
 
         output = ui.config('profiling', 'output')
 
         if output:
             path = os.path.expanduser(output)
             path = ui.expandpath(path)
             ostream = open(path, 'wb')
         else:
             ostream = sys.stderr
 
         try:
             from mercurial import lsprof
         except ImportError:
             raise util.Abort(_(
                 'lsprof not available - install from '
                 'http://codespeak.net/svn/user/arigo/hack/misc/lsprof/'))
         p = lsprof.Profiler()
         p.enable(subcalls=True)
         try:
             return checkargs()
         finally:
             p.disable()
 
             if format == 'kcachegrind':
                 import lsprofcalltree
                 calltree = lsprofcalltree.KCacheGrind(p)
                 calltree.output(ostream)
             else:
                 # format == 'text'
                 stats = lsprof.Stats(p.getstats())
                 stats.sort()
                 stats.pprint(top=10, file=ostream, climit=5)
 
             if output:
                 ostream.close()
     else:
         return checkargs()

mercurial/error.py

@@ -1,67 +1,70 b''
 """
 error.py - Mercurial exceptions
 
 This allows us to catch exceptions at higher levels without forcing imports
 
 Copyright 2005-2008 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.
 """
 
 # Do not import anything here, please
 
 class RevlogError(Exception):
     pass
 
 class LookupError(RevlogError, KeyError):
     def __init__(self, name, index, message):
         self.name = name
         if isinstance(name, str) and len(name) == 20:
             from node import short
             name = short(name)
         RevlogError.__init__(self, '%s@%s: %s' % (index, name, message))
 
     def __str__(self):
         return RevlogError.__str__(self)
 
 class ParseError(Exception):
     """Exception raised on errors in parsing the command line."""
 
+class ConfigError(Exception):
+    'Exception raised when parsing config files'
+
 class RepoError(Exception):
     pass
 
 class CapabilityError(RepoError):
     pass
 
 class LockError(IOError):
     def __init__(self, errno, strerror, filename, desc):
         IOError.__init__(self, errno, strerror, filename)
         self.desc = desc
 
 class LockHeld(LockError):
     def __init__(self, errno, filename, desc, locker):
         LockError.__init__(self, errno, 'Lock held', filename, desc)
         self.locker = locker
 
 class LockUnavailable(LockError):
     pass
 
 class ResponseError(Exception):
     """Raised to print an error with part of output and exit."""
 
 class UnknownCommand(Exception):
     """Exception raised if command is not in the command table."""
 
 class AmbiguousCommand(Exception):
     """Exception raised if command shortcut matches more than one command."""
 
 # derived from KeyboardInterrupt to simplify some breakout code
 class SignalInterrupt(KeyboardInterrupt):
     """Exception raised on SIGTERM and SIGHUP."""
 
 class SignatureError(Exception):
     pass
 
 class Abort(Exception):
     """Raised if a command needs to print an error and exit."""

mercurial/ui.py

@@ -1,401 +1,358 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
+import config, traceback, util, error
 
-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)
+_booleans = {'1':True, 'yes':True, 'true':True, 'on':True,
+             '0':False, 'no':False, 'false':False, 'off':False}
 
 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
-        self.overlay = util.configparser()
-        self.cdata = util.configparser()
-        self.ucdata = util.configparser()
+        self.overlay = config.config()
+        self.cdata = config.config()
+        self.ucdata = config.config()
         self.parentui = None
         self.trusted_users = {}
         self.trusted_groups = {}
 
         if parentui:
             # parentui may point to an ui object which is already a child
             self.parentui = parentui.parentui or parentui
-            updateconfig(self.parentui.cdata, self.cdata)
-            updateconfig(self.parentui.ucdata, self.ucdata)
+            self.cdata.update(self.parentui.cdata)
+            self.ucdata.update(self.parentui.ucdata)
             # we want the overlay from the parent, not the root
-            updateconfig(parentui.overlay, self.overlay)
+            self.overlay.update(parentui.overlay)
             self.buffers = parentui.buffers
             self.trusted_users = parentui.trusted_users.copy()
             self.trusted_groups = parentui.trusted_groups.copy()
             self.fixconfig()
         else:
             # we always trust global config files
             for f in util.rcpath():
                 self.readconfig(f, assumetrusted=True)
 
     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, 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
 
-        cdata = util.configparser()
+        cdata = config.config()
         trusted = sections or assumetrusted or self._is_trusted(fp, filename)
 
         try:
-            cdata.readfp(fp, filename)
-        except ConfigParser.ParsingError, inst:
-            msg = _("Failed to parse %s\n%s") % (filename, inst)
+            cdata.read(filename, fp)
+        except error.ConfigError, inst:
             if trusted:
-                raise util.Abort(msg)
-            self.warn(_("Ignored: %s\n") % msg)
+                raise
+            self.warn(_("Ignored: %s\n") % str(inst))
 
         if trusted:
-            updateconfig(cdata, self.cdata, sections)
-            updateconfig(self.overlay, self.cdata, sections)
-        updateconfig(cdata, self.ucdata, sections)
-        updateconfig(self.overlay, self.ucdata, sections)
+            self.cdata.update(cdata, sections)
+            self.cdata.update(self.overlay, sections)
+        self.ucdata.update(cdata, sections)
+        self.ucdata.update(self.overlay, sections)
 
         if root is None:
             root = os.path.expanduser('~')
         self.fixconfig(root=root)
 
     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'):
+                if not items and 'paths' in cdata:
                     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)
+    def config(self, section, name, default=None, untrusted=False):
+        value = self._get_cdata(untrusted).get(section, name, default)
         if self.debugflag and not untrusted:
-            uvalue = self._config(section, name, None, funcname,
-                                  untrusted=True, abort=False)
+            uvalue = self.ucdata.get(section, name)
             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)
+        v = self.config(section, name, None, untrusted)
+        if v == None:
+            return default
+        if v.lower() not in _booleans:
+            raise error.ConfigError(_("%s.%s not a boolean ('%s')")
+                                    % (section, name, v))
+        return _booleans[v.lower()]
 
     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
+        return section in self._get_cdata(untrusted)
 
     def configitems(self, section, untrusted=False):
-        items = self._configitems(section, untrusted=untrusted, abort=True)
+        items = self._get_cdata(untrusted).items(section)
         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):
+            for k,v in self.ucdata.items(section):
+                if self.cdata.get(section, k) != v:
                     self.warn(_("Ignoring untrusted configuration option "
-                                "%s.%s = %s\n") % (section, k, uitems[k]))
-        return util.sort(items.items())
+                                "%s.%s = %s\n") % (section, k, v))
+        return items
 
     def walkconfig(self, untrusted=False):
         cdata = self._get_cdata(untrusted)
-        sections = cdata.sections()
-        sections.sort()
-        for section in sections:
+        for section in cdata.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-hgrc.out

@@ -1,16 +1,13 b''
-abort: Failed to parse .../t/.hg/hgrc
-File contains no section headers.
-file: .../t/.hg/hgrc, line: 1
-'invalid\n'
+hg: config error at .../t/.hg/hgrc:1: 'invalid'
 updating working directory
 0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 [paths]
 default = .../foo%%bar
-default = .../foo%bar
+default = .../foo%%bar
 bundle.mainreporoot=.../foobar
 defaults.backout=-d "0 0"
 defaults.commit=-d "0 0"
 defaults.debugrawcommit=-d "0 0"
 defaults.tag=-d "0 0"
-paths.default=.../foo%bar
+paths.default=.../foo%%bar
 ui.slash=True

tests/test-trusted.py

@@ -1,211 +1,190 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
+from mercurial import ui, util, error
 
 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.readconfig sections"
 filename = 'foobar'
 f = open(filename, 'w')
 f.write('[foobar]\n')
 f.write('baz = quux\n')
 f.close()
 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.write('foo')
 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))
+try:
+    testui(user='abc', group='def', silent=True)
+except error.ConfigError, inst:
+    print inst
 
-print '# configitems:'
-print '  trusted ',
-print u.configitems('foo')
-print 'untrusted',
-assertraises(lambda: u.configitems('foo', untrusted=True))
-
+try:
+    testui(debug=True, silent=True)
+except error.ConfigError, inst:
+    print inst

tests/test-trusted.py.out

@@ -1,211 +1,160 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.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
+Ignored: config error at .hg/hgrc:1: 'foo'
 # 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
+config error at .hg/hgrc:1: 'foo'

tests/test-ui-config

@@ -1,90 +1,55 b''
 #!/usr/bin/env python
 
-import ConfigParser
-from mercurial import ui, util, dispatch
+from mercurial import ui, util, dispatch, error
 
 testui = ui.ui()
 parsed = dispatch._parseconfig(testui, [
     'values.string=string value',
     'values.bool1=true',
     'values.bool2=false',
     'lists.list1=foo',
     'lists.list2=foo bar baz',
     'lists.list3=alice, bob',
     'lists.list4=foo bar baz alice, bob',
-    'interpolation.value1=hallo',
-    'interpolation.value2=%(value1)s world',
-    'interpolation.value3=%(novalue)s',
-    'interpolation.value4=%(bad)1',
-    'interpolation.value5=%bad2',
 ])
 
 print repr(testui.configitems('values'))
 print repr(testui.configitems('lists'))
-try:
-    print repr(testui.configitems('interpolation'))
-except util.Abort, inst:
-    print inst
 print "---"
 print repr(testui.config('values', 'string'))
 print repr(testui.config('values', 'bool1'))
 print repr(testui.config('values', 'bool2'))
 print repr(testui.config('values', 'unknown'))
 print "---"
 try:
     print repr(testui.configbool('values', 'string'))
-except util.Abort, inst:
+except error.ConfigError, inst:
     print inst
 print repr(testui.configbool('values', 'bool1'))
 print repr(testui.configbool('values', 'bool2'))
 print repr(testui.configbool('values', 'bool2', True))
 print repr(testui.configbool('values', 'unknown'))
 print repr(testui.configbool('values', 'unknown', True))
 print "---"
 print repr(testui.configlist('lists', 'list1'))
 print repr(testui.configlist('lists', 'list2'))
 print repr(testui.configlist('lists', 'list3'))
 print repr(testui.configlist('lists', 'list4'))
 print repr(testui.configlist('lists', 'list4', ['foo']))
 print repr(testui.configlist('lists', 'unknown'))
 print repr(testui.configlist('lists', 'unknown', ''))
 print repr(testui.configlist('lists', 'unknown', 'foo'))
 print repr(testui.configlist('lists', 'unknown', ['foo']))
 print repr(testui.configlist('lists', 'unknown', 'foo bar'))
 print repr(testui.configlist('lists', 'unknown', 'foo, bar'))
 print repr(testui.configlist('lists', 'unknown', ['foo bar']))
 print repr(testui.configlist('lists', 'unknown', ['foo', 'bar']))
-print "---"
-print repr(testui.config('interpolation', 'value1'))
-print repr(testui.config('interpolation', 'value2'))
-try:
-    print repr(testui.config('interpolation', 'value3'))
-except util.Abort, inst:
-    print inst
-try:
-    print repr(testui.config('interpolation', 'value4'))
-except util.Abort, inst:
-    print inst
-try:
-    print repr(testui.config('interpolation', 'value5'))
-except util.Abort, inst:
-    print inst
-print "---"
 
-cp = util.configparser()
-cp.add_section('foo')
-cp.set('foo', 'bar', 'baz')
-try:
-    # should fail - keys are case-sensitive
-    cp.get('foo', 'Bar')
-except ConfigParser.NoOptionError, inst:
-    print inst
+print repr(testui.config('values', 'String'))
 
 def function():
     pass
 
-cp.add_section('hook')
 # values that aren't strings should work
-cp.set('hook', 'commit', function)
-f = cp.get('hook', 'commit')
-print "f %s= function" % (f == function and '=' or '!')
+testui.setconfig('hook', 'commit', function)
+print function == testui.config('hook', 'commit')

tests/test-ui-config.out

@@ -1,48 +1,30 b''
-[('bool1', 'true'), ('bool2', 'false'), ('string', 'string value')]
+[('string', 'string value'), ('bool1', 'true'), ('bool2', 'false')]
 [('list1', 'foo'), ('list2', 'foo bar baz'), ('list3', 'alice, bob'), ('list4', 'foo bar baz alice, bob')]
-Error in configuration section [interpolation]:
-'%' must be followed by '%' or '(', found: '%bad2'
 ---
 'string value'
 'true'
 'false'
 None
 ---
-Error in configuration section [values] parameter 'string':
-Not a boolean: string value
+values.string not a boolean ('string value')
 True
 False
 False
 False
 True
 ---
 ['foo']
 ['foo', 'bar', 'baz']
 ['alice', 'bob']
 ['foo', 'bar', 'baz', 'alice', 'bob']
 ['foo', 'bar', 'baz', 'alice', 'bob']
 []
 []
 ['foo']
 ['foo']
 ['foo', 'bar']
 ['foo', 'bar']
 ['foo bar']
 ['foo', 'bar']
----
-'hallo'
-'hallo world'
-Error in configuration section [interpolation] parameter 'value3':
-Bad value substitution:
-	section: [interpolation]
-	option : value3
-	key    : novalue
-	rawval : 
-
-Error in configuration section [interpolation] parameter 'value4':
-bad interpolation variable reference '%(bad)1'
-Error in configuration section [interpolation] parameter 'value5':
-'%' must be followed by '%' or '(', found: '%bad2'
----
-No option 'Bar' in section: 'foo'
-f == function
+None
+True