mercurial: comparison contrib/testparseutil.py

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 import sys
 ####################
 # for Python3 compatibility (almost comes from mercurial/pycompat.py)
-ispy3 = (sys.version_info[0] >= 3)
+ispy3 = sys.version_info[0] >= 3
 def identity(a):
 return a
 def _rapply(f, xs):
 if xs is None:
 # assume None means non-value of optional data
 return xs
 return type(xs)(_rapply(f, x) for x in xs)
 if isinstance(xs, dict):
 return type(xs)((_rapply(f, k), _rapply(f, v)) for k, v in xs.items())
 return f(xs)
 def rapply(f, xs):
 if f is identity:
 # fast path mainly for py2
 return xs
 return _rapply(f, xs)
 if ispy3:
 import builtins
 def bytestr(s):
 # tiny version of pycompat.bytestr
 return s
 return s.decode(u'latin-1')
 def opentext(f):
 return open(f, 'r')
 else:
 bytestr = str
 sysstr = identity
 opentext = open
 def b2s(x):
 # convert BYTES elements in "x" to SYSSTR recursively
 return rapply(sysstr, x)
 def writeout(data):
 # write "data" in BYTES into stdout
 sys.stdout.write(data)
 def writeerr(data):
 # write "data" in BYTES into stderr
 sys.stderr.write(data)
 ####################
 class embeddedmatcher(object):
 """Base class to detect embedded code fragments in *.t test script
 """
 __metaclass__ = abc.ABCMeta
 def __init__(self, desc):
 self.desc = desc
 """
 @abc.abstractmethod
 def codeinside(self, ctx, line):
 """Return actual code at line inside embedded code"""
 def embedded(basefile, lines, errors, matchers):
 """pick embedded code fragments up from given lines
 This is common parsing logic, which examines specified matchers on
 >>> b2s(errors)
 ['<dummy>:1: ambiguous line for "ambiguous #1", "ambiguous #2"']
 """
 matcher = None
-ctx = filename = code = startline = None # for pyflakes
+ctx = filename = code = startline = None  # for pyflakes
 for lineno, line in enumerate(lines, 1):
 if not line.endswith('\n'):
-line += '\n' # to normalize EOF line
+line += '\n'  # to normalize EOF line
-if matcher: # now, inside embedded code
+if matcher:  # now, inside embedded code
 if matcher.endsat(ctx, line):
 codeatend = matcher.codeatend(ctx, line)
 if codeatend is not None:
 code.append(codeatend)
 if not matcher.ignores(ctx):
 matcher = None
 # DO NOT "continue", because line might start next fragment
 elif not matcher.isinside(ctx, line):
 # this is an error of basefile
 # (if matchers are implemented correctly)
-errors.append('%s:%d: unexpected line for "%s"'
+errors.append(
-% (basefile, lineno, matcher.desc))
+'%s:%d: unexpected line for "%s"'
+% (basefile, lineno, matcher.desc)
+)
 # stop extracting embedded code by current 'matcher',
 # because appearance of unexpected line might mean
 # that expected end-of-embedded-code line might never
 # appear
 matcher = None
 if ctx:
 matched.append((m, ctx))
 if matched:
 if len(matched) > 1:
 # this is an error of matchers, maybe
-errors.append('%s:%d: ambiguous line for %s' %
+errors.append(
-(basefile, lineno,
+'%s:%d: ambiguous line for %s'
-', '.join(['"%s"' % m.desc
+% (
-for m, c in matched])))
+basefile,
+lineno,
+', '.join(['"%s"' % m.desc for m, c in matched]),
+)
+)
 # omit extracting embedded code, because choosing
 # arbitrary matcher from matched ones might fail to
 # detect the end of embedded code as expected.
 continue
 matcher, ctx = matched[0]
 if not matcher.ignores(ctx):
 yield (filename, startline, lineno + 1, ''.join(code))
 else:
 # this is an error of basefile
 # (if matchers are implemented correctly)
-errors.append('%s:%d: unexpected end of file for "%s"'
+errors.append(
-% (basefile, lineno, matcher.desc))
+'%s:%d: unexpected end of file for "%s"'
+% (basefile, lineno, matcher.desc)
+)
 # heredoc limit mark to ignore embedded code at check-code.py or so
 heredocignorelimit = 'NO_CHECK_EOF'
 # the pattern to match against cases below, and to return a limit mark
 #
 # - << LIMITMARK
 # - << "LIMITMARK"
 # - << 'LIMITMARK'
 heredoclimitpat = r'\s*<<\s*(?P<lquote>["\']?)(?P<limit>\w+)(?P=lquote)'
 class fileheredocmatcher(embeddedmatcher):
 """Detect "cat > FILE << LIMIT" style embedded code
 >>> matcher = fileheredocmatcher('heredoc .py file', r'[^<]+\\.py')
 False
 >>> ctx = matcher.startsat('  $ cat > file.py << NO_CHECK_EOF\\n')
 >>> matcher.ignores(ctx)
 True
 """
 _prefix = '  > '
 def __init__(self, desc, namepat):
 super(fileheredocmatcher, self).__init__(desc)
 # group
 #
 # - > NAMEPAT
 # - > "NAMEPAT"
 # - > 'NAMEPAT'
-namepat = (r'\s*>>?\s*(?P<nquote>["\']?)(?P<name>%s)(?P=nquote)'
+namepat = (
-% namepat)
+r'\s*>>?\s*(?P<nquote>["\']?)(?P<name>%s)(?P=nquote)' % namepat
+)
 self._fileres = [
 # "cat > NAME << LIMIT" case
 re.compile(r'  \$ \s*cat' + namepat + heredoclimitpat),
 # "cat << LIMIT > NAME" case
 re.compile(r'  \$ \s*cat' + heredoclimitpat + namepat),
 def startsat(self, line):
 # ctx is (filename, END-LINE-OF-EMBEDDED-CODE) tuple
 for filere in self._fileres:
 matched = filere.match(line)
 if matched:
-return (matched.group('name'),
+return (
-'  > %s\n' % matched.group('limit'))
+matched.group('name'),
+'  > %s\n' % matched.group('limit'),
+)
 def endsat(self, ctx, line):
 return ctx[1] == line
 def isinside(self, ctx, line):
 def filename(self, ctx):
 return ctx[0]
 def codeatstart(self, ctx, line):
-return None # no embedded code at start line
+return None  # no embedded code at start line
 def codeatend(self, ctx, line):
-return None # no embedded code at end line
+return None  # no embedded code at end line
 def codeinside(self, ctx, line):
-return line[len(self._prefix):] # strip prefix
+return line[len(self._prefix) :]  # strip prefix
 ####
 # for embedded python script
 class pydoctestmatcher(embeddedmatcher):
 """Detect ">>> code" style embedded python code
 >>> matcher = pydoctestmatcher()
 >>> end = '\\n'
 >>> matcher.endsat(ctx, end)
 True
 >>> matcher.codeatend(ctx, end)
 """
 _prefix = '  >>> '
 _prefixre = re.compile(r'  (>>>|\.\.\.) ')
 # If a line matches against not _prefixre but _outputre, that line
 # is "an expected output line" (= not a part of code fragment).
 def endsat(self, ctx, line):
 return not (self._prefixre.match(line) or self._outputre.match(line))
 def isinside(self, ctx, line):
-return True # always true, if not yet ended
+return True  # always true, if not yet ended
 def ignores(self, ctx):
-return False # should be checked always
+return False  # should be checked always
 def filename(self, ctx):
-return None # no filename
+return None  # no filename
 def codeatstart(self, ctx, line):
-return line[len(self._prefix):] # strip prefix '  >>> '/'  ... '
+return line[len(self._prefix) :]  # strip prefix '  >>> '/'  ... '
 def codeatend(self, ctx, line):
-return None # no embedded code at end line
+return None  # no embedded code at end line
 def codeinside(self, ctx, line):
 if self._prefixre.match(line):
-return line[len(self._prefix):] # strip prefix '  >>> '/'  ... '
+return line[len(self._prefix) :]  # strip prefix '  >>> '/'  ... '
-return '\n' # an expected output line is treated as an empty line
+return '\n'  # an expected output line is treated as an empty line
 class pyheredocmatcher(embeddedmatcher):
 """Detect "python << LIMIT" style embedded python code
 >>> matcher = pyheredocmatcher()
 False
 >>> ctx = matcher.startsat('  $ python << NO_CHECK_EOF\\n')
 >>> matcher.ignores(ctx)
 True
 """
 _prefix = '  > '
-_startre = re.compile(r'  \$ (\$PYTHON|"\$PYTHON"|python).*' +
+_startre = re.compile(
-heredoclimitpat)
+r'  \$ (\$PYTHON|"\$PYTHON"|python).*' + heredoclimitpat
+)
 def __init__(self):
 super(pyheredocmatcher, self).__init__("heredoc python invocation")
 def startsat(self, line):
 def ignores(self, ctx):
 return '  > %s\n' % heredocignorelimit == ctx
 def filename(self, ctx):
-return None # no filename
+return None  # no filename
 def codeatstart(self, ctx, line):
-return None # no embedded code at start line
+return None  # no embedded code at start line
 def codeatend(self, ctx, line):
-return None # no embedded code at end line
+return None  # no embedded code at end line
 def codeinside(self, ctx, line):
-return line[len(self._prefix):] # strip prefix
+return line[len(self._prefix) :]  # strip prefix
 _pymatchers = [
 pydoctestmatcher(),
 pyheredocmatcher(),
 # use '[^<]+' instead of '\S+', in order to match against
 # paths including whitespaces
 fileheredocmatcher('heredoc .py file', r'[^<]+\.py'),
 ]
 def pyembedded(basefile, lines, errors):
 return embedded(basefile, lines, errors, _pymatchers)
 ####
 # for embedded shell script
 _shmatchers = [
 # use '[^<]+' instead of '\S+', in order to match against
 # paths including whitespaces
 fileheredocmatcher('heredoc .sh file', r'[^<]+\.sh'),
 ]
 def shembedded(basefile, lines, errors):
 return embedded(basefile, lines, errors, _shmatchers)
 ####
 # for embedded hgrc configuration
 _hgrcmatchers = [
 # use '[^<]+' instead of '\S+', in order to match against
 # paths including whitespaces
-fileheredocmatcher('heredoc hgrc file',
+fileheredocmatcher(
-r'(([^/<]+/)+hgrc|\$HGRCPATH|\${HGRCPATH})'),
+'heredoc hgrc file', r'(([^/<]+/)+hgrc|\$HGRCPATH|\${HGRCPATH})'
+),
 ]
 def hgrcembedded(basefile, lines, errors):
 return embedded(basefile, lines, errors, _hgrcmatchers)
 ####
 if __name__ == "__main__":
 import optparse
 for name, starts, ends, code in embeddedfunc(basefile, lines, errors):
 if not name:
 name = '<anonymous>'
 writeout("%s:%d: %s starts\n" % (basefile, starts, name))
 if opts.verbose and code:
-writeout("  |%s\n" %
+writeout("  |%s\n" % "\n  |".join(l for l in code.splitlines()))
-"\n  |".join(l for l in code.splitlines()))
 writeout("%s:%d: %s ends\n" % (basefile, ends, name))
 for e in errors:
 writeerr("%s\n" % e)
 return len(errors)
 if showembedded('<stdin>', lines, embeddedfunc, opts):
 ret = 1
 return ret
 commands = {}
 def command(name, desc):
 def wrap(func):
 commands[name] = (desc, func)
 return wrap
 @command("pyembedded", "detect embedded python script")
 def pyembeddedcmd(args, opts):
 return applyembedded(args, pyembedded, opts)
 @command("hgrcembedded", "detect embedded hgrc configuration")
 def hgrcembeddedcmd(args, opts):
 return applyembedded(args, hgrcembedded, opts)
-availablecommands = "\n".join(["  - %s: %s" % (key, value[0])
+availablecommands = "\n".join(
-for key, value in commands.items()])
+["  - %s: %s" % (key, value[0]) for key, value in commands.items()]
+)
-parser = optparse.OptionParser("""%prog COMMAND [file ...]
+parser = optparse.OptionParser(
+"""%prog COMMAND [file ...]
 Pick up embedded code fragments from given file(s) or stdin, and list
 up start/end lines of them in standard compiler format
 ("FILENAME:LINENO:").
 Available commands are:
-""" + availablecommands + """
+"""
-""")
++ availablecommands
-parser.add_option("-v", "--verbose",
++ """
-help="enable additional output (e.g. actual code)",
+"""
-action="store_true")
+)
+parser.add_option(
+"-v",
+"--verbose",
+help="enable additional output (e.g. actual code)",
+action="store_true",
+)
 (opts, args) = parser.parse_args()
 if not args or args[0] not in commands:
 parser.print_help()
 sys.exit(255)

changeset 43076	2372284d9457
parent 42391	c2deb2512823
child 43091	127cc1f72e70