eric: comparison ThirdParty/Pygments/pygments/cmdline.py

-:bf4d19a7cade
+:c2e9bf425554
 pygments.cmdline
 ~~~~~~~~~~~~~~~~
 Command line interface.
-:copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
+:copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
 :license: BSD, see LICENSE for details.
 """
 from __future__ import print_function
 from pygments import __version__, highlight
 from pygments.util import ClassNotFound, OptionError, docstring_headline, \
 guess_decode, guess_decode_from_terminal, terminal_encoding
 from pygments.lexers import get_all_lexers, get_lexer_by_name, guess_lexer, \
-get_lexer_for_filename, find_lexer_class, TextLexer
+get_lexer_for_filename, find_lexer_class_for_filename
+from pygments.lexers.special import TextLexer
 from pygments.formatters.latex import LatexEmbeddedLexer, LatexFormatter
 from pygments.formatters import get_all_formatters, get_formatter_by_name, \
-get_formatter_for_filename, find_formatter_class, \
+get_formatter_for_filename, find_formatter_class
-TerminalFormatter  # pylint:disable-msg=E0611
+from pygments.formatters.terminal import TerminalFormatter
 from pygments.filters import get_all_filters, find_filter_class
 from pygments.styles import get_all_styles, get_style_by_name
 USAGE = """\
 Usage: %s [-l <lexer> | -g] [-F <filter>[:<options>]] [-f <formatter>]
-[-O <options>] [-P <option=value>] [-s] [-o <outfile>] [<infile>]
+[-O <options>] [-P <option=value>] [-s] [-v] [-o <outfile>] [<infile>]
 %s -S <style> -f <formatter> [-a <arg>] [-O <options>] [-P <option=value>]
 %s -L [<which> ...]
 %s -N <filename>
 %s -H <type> <name>
 The -s option processes lines one at a time until EOF, rather than
 waiting to process the entire file.  This only works for stdin, and
 is intended for streaming input such as you get from 'tail -f'.
 Example usage: "tail -f sql.log | pygmentize -s -l sql"
+The -v option prints a detailed traceback on unhandled exceptions,
+which is useful for debugging and bug reports.
 The -h option prints this help.
 The -V option prints the package version.
 """
 def _parse_options(o_strs):
 opts = {}
 if not o_strs:
 return opts
 for o_str in o_strs:
-if not o_str:
+if not o_str.strip():
 continue
 o_args = o_str.split(',')
 for o_arg in o_args:
 o_arg = o_arg.strip()
 try:
 def _print_help(what, name):
 try:
 if what == 'lexer':
-cls = find_lexer_class(name)
+cls = get_lexer_by_name(name)
 print("Help on the %s lexer:" % cls.name)
 print(dedent(cls.__doc__))
 elif what == 'formatter':
 cls = find_formatter_class(name)
 print("Help on the %s formatter:" % cls.name)
 print(dedent(cls.__doc__))
 elif what == 'filter':
 cls = find_filter_class(name)
 print("Help on the %s filter:" % name)
 print(dedent(cls.__doc__))
-except AttributeError:
+return 0
+except (AttributeError, ValueError):
 print("%s not found!" % what, file=sys.stderr)
+return 1
 def _print_list(what):
 if what == 'lexer':
 print()
 if opts.pop('-h', None) is not None:
 print(usage)
 return 0
 if opts.pop('-V', None) is not None:
-print('Pygments version %s, (c) 2006-2014 by Georg Brandl.' % __version__)
+print('Pygments version %s, (c) 2006-2015 by Georg Brandl.' % __version__)
 return 0
 # handle ``pygmentize -L``
 L_opt = opts.pop('-L', None)
 if L_opt is not None:
 if H_opt is not None:
 if opts or len(args) != 2:
 print(usage, file=sys.stderr)
 return 2
-what, name = args
+what, name = args  # pylint: disable=unbalanced-tuple-unpacking
 if what not in ('lexer', 'formatter', 'filter'):
 print(usage, file=sys.stderr)
 return 2
-_print_help(what, name)
+return _print_help(what, name)
-return 0
 # parse -O options
 parsed_opts = _parse_options(O_opts)
 opts.pop('-O', None)
 else:
 parsed_opts[name] = value
 opts.pop('-P', None)
 # encodings
-inencoding  = parsed_opts.get('inencoding', parsed_opts.get('encoding'))
+inencoding = parsed_opts.get('inencoding', parsed_opts.get('encoding'))
 outencoding = parsed_opts.get('outencoding', parsed_opts.get('encoding'))
 # handle ``pygmentize -N``
 infn = opts.pop('-N', None)
 if infn is not None:
-try:
+lexer = find_lexer_class_for_filename(infn)
-lexer = get_lexer_for_filename(infn, **parsed_opts)
+if lexer is None:
-except ClassNotFound as err:
+lexer = TextLexer
-lexer = TextLexer()
-except OptionError as err:
-print('Error:', err, file=sys.stderr)
-return 1
 print(lexer.aliases[0])
 return 0
 # handle ``pygmentize -S``
 fmter = get_formatter_by_name(f_opt, **parsed_opts)
 except ClassNotFound as err:
 print(err, file=sys.stderr)
 return 1
-arg = a_opt or ''
+print(fmter.get_style_defs(a_opt or ''))
-try:
-print(fmter.get_style_defs(arg))
-except Exception as err:
-print('Error:', err, file=sys.stderr)
-return 1
 return 0
 # if no -S is given, -a is not allowed
 if a_opt is not None:
 print(usage, file=sys.stderr)
 return 2
 if '-s' in opts:
 print('Error: -s option not usable when input file specified',
 file=sys.stderr)
-return 1
+return 2
 infn = args[0]
 try:
 with open(infn, 'rb') as infp:
 code = infp.read()
 try:
 lexer = guess_lexer(code, **parsed_opts)
 except ClassNotFound:
 lexer = TextLexer(**parsed_opts)
+else:  # -s option needs a lexer with -l
+if not lexer:
+print('Error: when using -s a lexer has to be selected with -l',
+file=sys.stderr)
+return 2
+# process filters
+for fname, fopts in F_opts:
+try:
+lexer.add_filter(fname, **fopts)
+except ClassNotFound as err:
+print('Error:', err, file=sys.stderr)
+return 1
 # select formatter
 outfn = opts.pop('-o', None)
 fmter = opts.pop('-f', None)
 if fmter:
 try:
 # else use terminal encoding
 fmter.encoding = terminal_encoding(sys.stdout)
 # provide coloring under Windows, if possible
 if not outfn and sys.platform in ('win32', 'cygwin') and \
-fmter.name in ('Terminal', 'Terminal256'):
+fmter.name in ('Terminal', 'Terminal256'):  # pragma: no cover
 # unfortunately colorama doesn't support binary streams on Py3
 if sys.version_info > (3,):
 from pygments.util import UnclosingTextIOWrapper
 outfile = UnclosingTextIOWrapper(outfile, encoding=fmter.encoding)
 fmter.encoding = None
 if len(escapeinside) == 2 and isinstance(fmter, LatexFormatter):
 left = escapeinside[0]
 right = escapeinside[1]
 lexer = LatexEmbeddedLexer(left, right, lexer)
-# process filters
-for fname, fopts in F_opts:
-try:
-lexer.add_filter(fname, **fopts)
-except ClassNotFound as err:
-print('Error:', err, file=sys.stderr)
-return 1
 # ... and do it!
 if '-s' not in opts:
 # process whole input as per normal...
 highlight(code, lexer, fmter, outfile)
 return 0
 else:
-if not lexer:
-print('Error: when using -s a lexer has to be selected with -l',
-file=sys.stderr)
-return 1
 # line by line processing of stdin (eg: for 'tail -f')...
 try:
 while 1:
 if sys.version_info > (3,):
 # Python 3: we have to use .buffer to get a binary stream
 if not inencoding:
 line = guess_decode_from_terminal(line, sys.stdin)[0]
 highlight(line, lexer, fmter, outfile)
 if hasattr(outfile, 'flush'):
 outfile.flush()
-except KeyboardInterrupt:
+return 0
+except KeyboardInterrupt:  # pragma: no cover
 return 0
 def main(args=sys.argv):
 """
 Main command line entry point.
 """
 usage = USAGE % ((args[0],) * 6)
 try:
-popts, args = getopt.getopt(args[1:], "l:f:F:o:O:P:LS:a:N:hVHgs")
+popts, args = getopt.getopt(args[1:], "l:f:F:o:O:P:LS:a:N:vhVHgs")
 except getopt.GetoptError:
 print(usage, file=sys.stderr)
 return 2
 try:
 return main_inner(popts, args, usage)
 except Exception:
+if '-v' in dict(popts):
+print(file=sys.stderr)
+print('*' * 65, file=sys.stderr)
+print('An unhandled exception occurred while highlighting.',
+file=sys.stderr)
+print('Please report the whole traceback to the issue tracker at',
+file=sys.stderr)
+print('<https://bitbucket.org/birkenfeld/pygments-main/issues>.',
+file=sys.stderr)
+print('*' * 65, file=sys.stderr)
+print(file=sys.stderr)
+raise
 import traceback
 info = traceback.format_exception(*sys.exc_info())
 msg = info[-1].strip()
 if len(info) >= 3:
 # extract relevant file and position info
 msg += '\n   (f%s)' % info[-2].split('\n')[0].strip()[1:]
 print(file=sys.stderr)
 print('*** Error while highlighting:', file=sys.stderr)
 print(msg, file=sys.stderr)
+print('*** If this is a bug you want to report, please rerun with -v.',
+file=sys.stderr)
 return 1

Mercurial Repositories > eric / file comparison

comparison: ThirdParty/Pygments/pygments/cmdline.py

ThirdParty/Pygments/pygments/cmdline.py