check-config: syntax to allow inconsistent config values

The ignore regular expression has been updated to detect
"inconsistent config." If present, we track which configs have
that set and we suppress the conflicting defaults error for those
options.

I also added named groups to the regexp to aid readability.

A comment was added to profiling.py to make a desired inconsistent
value error go away.

contrib/check-config.py

@@ -1,130 +1,139 b''
 #!/usr/bin/env python
 #
 # check-config - a config flag documentation checker for Mercurial
 #
 # Copyright 2015 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import, print_function
 import re
 import sys
 
 foundopts = {}
 documented = {}
+allowinconsistent = set()
 
 configre = re.compile(r'''
     # Function call
     ui\.config(?P<ctype>|int|bool|list)\(
         # First argument.
         ['"](?P<section>\S+)['"],\s*
         # Second argument
         ['"](?P<option>\S+)['"](,\s+
         (?:default=)?(?P<default>\S+?))?
     \)''', re.VERBOSE | re.MULTILINE)
 
 configwithre = re.compile('''
     ui\.config(?P<ctype>with)\(
         # First argument is callback function. This doesn't parse robustly
         # if it is e.g. a function call.
         [^,]+,\s*
         ['"](?P<section>\S+)['"],\s*
         ['"](?P<option>\S+)['"](,\s+
         (?:default=)?(?P<default>\S+?))?
     \)''', re.VERBOSE | re.MULTILINE)
 
 configpartialre = (r"""ui\.config""")
 
+ignorere = re.compile(r'''
+    \#\s(?P<reason>internal|experimental|deprecated|developer|inconsistent)\s
+    config:\s(?P<config>\S+\.\S+)$
+    ''', re.VERBOSE | re.MULTILINE)
+
 def main(args):
     for f in args:
         sect = ''
         prevname = ''
         confsect = ''
         carryover = ''
         for l in open(f):
 
             # check topic-like bits
             m = re.match('\s*``(\S+)``', l)
             if m:
                 prevname = m.group(1)
             if re.match('^\s*-+$', l):
                 sect = prevname
                 prevname = ''
 
             if sect and prevname:
                 name = sect + '.' + prevname
                 documented[name] = 1
 
             # check docstring bits
             m = re.match(r'^\s+\[(\S+)\]', l)
             if m:
                 confsect = m.group(1)
                 continue
             m = re.match(r'^\s+(?:#\s*)?(\S+) = ', l)
             if m:
                 name = confsect + '.' + m.group(1)
                 documented[name] = 1
 
             # like the bugzilla extension
             m = re.match(r'^\s*(\S+\.\S+)$', l)
             if m:
                 documented[m.group(1)] = 1
 
             # like convert
             m = re.match(r'^\s*:(\S+\.\S+):\s+', l)
             if m:
                 documented[m.group(1)] = 1
 
             # quoted in help or docstrings
             m = re.match(r'.*?``(\S+\.\S+)``', l)
             if m:
                 documented[m.group(1)] = 1
 
             # look for ignore markers
-            m = re.search(r'# (?:internal|experimental|deprecated|developer)'
-                          ' config: (\S+\.\S+)$', l)
+            m = ignorere.search(l)
             if m:
-                documented[m.group(1)] = 1
+                if m.group('reason') == 'inconsistent':
+                    allowinconsistent.add(m.group('config'))
+                else:
+                    documented[m.group('config')] = 1
 
             # look for code-like bits
             line = carryover + l
             m = configre.search(line) or configwithre.search(line)
             if m:
                 ctype = m.group('ctype')
                 if not ctype:
                     ctype = 'str'
                 name = m.group('section') + "." + m.group('option')
                 default = m.group('default')
                 if default in (None, 'False', 'None', '0', '[]', '""', "''"):
                     default = ''
                 if re.match('[a-z.]+$', default):
                     default = '<variable>'
-                if name in foundopts and (ctype, default) != foundopts[name]:
+                if (name in foundopts and (ctype, default) != foundopts[name]
+                    and name not in allowinconsistent):
                     print(l)
                     print("conflict on %s: %r != %r" % (name, (ctype, default),
                                                         foundopts[name]))
                 foundopts[name] = (ctype, default)
                 carryover = ''
             else:
                 m = re.search(configpartialre, line)
                 if m:
                     carryover = line
                 else:
                     carryover = ''
 
     for name in sorted(foundopts):
         if name not in documented:
             if not (name.startswith("devel.") or
                     name.startswith("experimental.") or
                     name.startswith("debug.")):
                 ctype, default = foundopts[name]
                 if default:
                     default = ' [%s]' % default
                 print("undocumented: %s (%s)%s" % (name, ctype, default))
 
 if __name__ == "__main__":
     if len(sys.argv) > 1:
         sys.exit(main(sys.argv[1:]))
     else:
         sys.exit(main([l.rstrip() for l in sys.stdin]))

mercurial/profiling.py

@@ -1,237 +1,238 b''
 # profiling.py - profiling functions
 #
 # Copyright 2016 Gregory Szorc <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import, print_function
 
 import contextlib
 
 from .i18n import _
 from . import (
     encoding,
     error,
     extensions,
     util,
 )
 
 def _loadprofiler(ui, profiler):
     """load profiler extension. return profile method, or None on failure"""
     extname = profiler
     extensions.loadall(ui, whitelist=[extname])
     try:
         mod = extensions.find(extname)
     except KeyError:
         return None
     else:
         return getattr(mod, 'profile', None)
 
 @contextlib.contextmanager
 def lsprofile(ui, fp):
     format = ui.config('profiling', 'format', default='text')
     field = ui.config('profiling', 'sort', default='inlinetime')
     limit = ui.configint('profiling', 'limit', default=30)
     climit = ui.configint('profiling', 'nested', default=0)
 
     if format not in ['text', 'kcachegrind']:
         ui.warn(_("unrecognized profiling format '%s'"
                     " - Ignored\n") % format)
         format = 'text'
 
     try:
         from . import lsprof
     except ImportError:
         raise error.Abort(_(
             'lsprof not available - install from '
             'http://codespeak.net/svn/user/arigo/hack/misc/lsprof/'))
     p = lsprof.Profiler()
     p.enable(subcalls=True)
     try:
         yield
     finally:
         p.disable()
 
         if format == 'kcachegrind':
             from . import lsprofcalltree
             calltree = lsprofcalltree.KCacheGrind(p)
             calltree.output(fp)
         else:
             # format == 'text'
             stats = lsprof.Stats(p.getstats())
             stats.sort(field)
             stats.pprint(limit=limit, file=fp, climit=climit)
 
 @contextlib.contextmanager
 def flameprofile(ui, fp):
     try:
         from flamegraph import flamegraph
     except ImportError:
         raise error.Abort(_(
             'flamegraph not available - install from '
             'https://github.com/evanhempel/python-flamegraph'))
     # developer config: profiling.freq
     freq = ui.configint('profiling', 'freq', default=1000)
     filter_ = None
     collapse_recursion = True
     thread = flamegraph.ProfileThread(fp, 1.0 / freq,
                                       filter_, collapse_recursion)
     start_time = util.timer()
     try:
         thread.start()
         yield
     finally:
         thread.stop()
         thread.join()
         print('Collected %d stack frames (%d unique) in %2.2f seconds.' % (
             util.timer() - start_time, thread.num_frames(),
             thread.num_frames(unique=True)))
 
 @contextlib.contextmanager
 def statprofile(ui, fp):
     from . import statprof
 
     freq = ui.configint('profiling', 'freq', default=1000)
     if freq > 0:
         # Cannot reset when profiler is already active. So silently no-op.
         if statprof.state.profile_level == 0:
             statprof.reset(freq)
     else:
         ui.warn(_("invalid sampling frequency '%s' - ignoring\n") % freq)
 
     statprof.start(mechanism='thread')
 
     try:
         yield
     finally:
         data = statprof.stop()
 
         profformat = ui.config('profiling', 'statformat', 'hotpath')
 
         formats = {
             'byline': statprof.DisplayFormats.ByLine,
             'bymethod': statprof.DisplayFormats.ByMethod,
             'hotpath': statprof.DisplayFormats.Hotpath,
             'json': statprof.DisplayFormats.Json,
             'chrome': statprof.DisplayFormats.Chrome,
         }
 
         if profformat in formats:
             displayformat = formats[profformat]
         else:
             ui.warn(_('unknown profiler output format: %s\n') % profformat)
             displayformat = statprof.DisplayFormats.Hotpath
 
         kwargs = {}
 
         def fraction(s):
             if isinstance(s, (float, int)):
                 return float(s)
             if s.endswith('%'):
                 v = float(s[:-1]) / 100
             else:
                 v = float(s)
             if 0 <= v <= 1:
                 return v
             raise ValueError(s)
 
         if profformat == 'chrome':
             showmin = ui.configwith(fraction, 'profiling', 'showmin', 0.005)
             showmax = ui.configwith(fraction, 'profiling', 'showmax', 0.999)
             kwargs.update(minthreshold=showmin, maxthreshold=showmax)
         elif profformat == 'hotpath':
+            # inconsistent config: profiling.showmin
             limit = ui.configwith(fraction, 'profiling', 'showmin', 0.05)
             kwargs['limit'] = limit
 
         statprof.display(fp, data=data, format=displayformat, **kwargs)
 
 class profile(object):
     """Start profiling.
 
     Profiling is active when the context manager is active. When the context
     manager exits, profiling results will be written to the configured output.
     """
     def __init__(self, ui, enabled=True):
         self._ui = ui
         self._output = None
         self._fp = None
         self._fpdoclose = True
         self._profiler = None
         self._enabled = enabled
         self._entered = False
         self._started = False
 
     def __enter__(self):
         self._entered = True
         if self._enabled:
             self.start()
         return self
 
     def start(self):
         """Start profiling.
 
         The profiling will stop at the context exit.
 
         If the profiler was already started, this has no effect."""
         if not self._entered:
             raise error.ProgrammingError()
         if self._started:
             return
         self._started = True
         profiler = encoding.environ.get('HGPROF')
         proffn = None
         if profiler is None:
             profiler = self._ui.config('profiling', 'type', default='stat')
         if profiler not in ('ls', 'stat', 'flame'):
             # try load profiler from extension with the same name
             proffn = _loadprofiler(self._ui, profiler)
             if proffn is None:
                 self._ui.warn(_("unrecognized profiler '%s' - ignored\n")
                               % profiler)
                 profiler = 'stat'
 
         self._output = self._ui.config('profiling', 'output')
 
         try:
             if self._output == 'blackbox':
                 self._fp = util.stringio()
             elif self._output:
                 path = self._ui.expandpath(self._output)
                 self._fp = open(path, 'wb')
             else:
                 self._fpdoclose = False
                 self._fp = self._ui.ferr
 
             if proffn is not None:
                 pass
             elif profiler == 'ls':
                 proffn = lsprofile
             elif profiler == 'flame':
                 proffn = flameprofile
             else:
                 proffn = statprofile
 
             self._profiler = proffn(self._ui, self._fp)
             self._profiler.__enter__()
         except: # re-raises
             self._closefp()
             raise
 
     def __exit__(self, exception_type, exception_value, traceback):
         propagate = None
         if self._profiler is not None:
             propagate = self._profiler.__exit__(exception_type, exception_value,
                                                 traceback)
             if self._output == 'blackbox':
                 val = 'Profile:\n%s' % self._fp.getvalue()
                 # ui.log treats the input as a format string,
                 # so we need to escape any % signs.
                 val = val.replace('%', '%%')
                 self._ui.log('profile', val)
         self._closefp()
         return propagate
 
     def _closefp(self):
         if self._fpdoclose and self._fp is not None:
             self._fp.close()

tests/test-check-config.t

@@ -1,38 +1,47 b''
 #require test-repo
 
   $ . "$TESTDIR/helpers-testrepo.sh"
 
 Sanity check check-config.py
 
   $ cat > testfile.py << EOF
   > # Good
   > foo = ui.config('ui', 'username')
   > # Missing
   > foo = ui.config('ui', 'doesnotexist')
   > # Missing different type
   > foo = ui.configint('ui', 'missingint')
   > # Missing with default value
   > foo = ui.configbool('ui', 'missingbool1', default=True)
   > foo = ui.configbool('ui', 'missingbool2', False)
+  > # Inconsistent values for defaults.
+  > foo = ui.configint('ui', 'intdefault', default=1)
+  > foo = ui.configint('ui', 'intdefault', default=42)
+  > # Can suppress inconsistent value error
+  > foo = ui.configint('ui', 'intdefault2', default=1)
+  > # inconsistent config: ui.intdefault2
+  > foo = ui.configint('ui', 'intdefault2', default=42)
   > EOF
 
   $ cat > files << EOF
   > mercurial/help/config.txt
   > $TESTTMP/testfile.py
   > EOF
 
   $ cd "$TESTDIR"/..
 
   $ $PYTHON contrib/check-config.py < $TESTTMP/files
+  foo = ui.configint('ui', 'intdefault', default=42)
+  
+  conflict on ui.intdefault: ('int', '42') != ('int', '1')
   undocumented: ui.doesnotexist (str)
+  undocumented: ui.intdefault (int) [42]
+  undocumented: ui.intdefault2 (int) [42]
   undocumented: ui.missingbool1 (bool) [True]
   undocumented: ui.missingbool2 (bool)
   undocumented: ui.missingint (int)
 
 New errors are not allowed. Warnings are strongly discouraged.
 
   $ syshg files "set:(**.py or **.txt) - tests/**" | sed 's|\\|/|g' |
   >   $PYTHON contrib/check-config.py
-              limit = ui.configwith(fraction, 'profiling', 'showmin', 0.05)
-  
-  conflict on profiling.showmin: ('with', '0.05') != ('with', '0.005')