| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430 |
- # -*- coding: utf-8 -*-
- """
- pygments.cmdline
- ~~~~~~~~~~~~~~~~
- Command line interface.
- :copyright: Copyright 2006-2010 by the Pygments team, see AUTHORS.
- :license: BSD, see LICENSE for details.
- """
- import sys
- import getopt
- from textwrap import dedent
- from pygments import __version__, highlight
- from pygments.util import ClassNotFound, OptionError, docstring_headline
- from pygments.lexers import get_all_lexers, get_lexer_by_name, get_lexer_for_filename, \
- find_lexer_class, guess_lexer, TextLexer
- from pygments.formatters import get_all_formatters, get_formatter_by_name, \
- get_formatter_for_filename, find_formatter_class, \
- TerminalFormatter # pylint:disable-msg=E0611
- 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>] [-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>
- %s -h | -V
- Highlight the input file and write the result to <outfile>.
- If no input file is given, use stdin, if -o is not given, use stdout.
- <lexer> is a lexer name (query all lexer names with -L). If -l is not
- given, the lexer is guessed from the extension of the input file name
- (this obviously doesn't work if the input is stdin). If -g is passed,
- attempt to guess the lexer from the file contents, or pass through as
- plain text if this fails (this can work for stdin).
- Likewise, <formatter> is a formatter name, and will be guessed from
- the extension of the output file name. If no output file is given,
- the terminal formatter will be used by default.
- With the -O option, you can give the lexer and formatter a comma-
- separated list of options, e.g. ``-O bg=light,python=cool``.
- The -P option adds lexer and formatter options like the -O option, but
- you can only give one option per -P. That way, the option value may
- contain commas and equals signs, which it can't with -O, e.g.
- ``-P "heading=Pygments, the Python highlighter".
- With the -F option, you can add filters to the token stream, you can
- give options in the same way as for -O after a colon (note: there must
- not be spaces around the colon).
- The -O, -P and -F options can be given multiple times.
- With the -S option, print out style definitions for style <style>
- for formatter <formatter>. The argument given by -a is formatter
- dependent.
- The -L option lists lexers, formatters, styles or filters -- set
- `which` to the thing you want to list (e.g. "styles"), or omit it to
- list everything.
- The -N option guesses and prints out a lexer name based solely on
- the given filename. It does not take input or highlight anything.
- If no specific lexer can be determined "text" is returned.
- The -H option prints detailed help for the object <name> of type <type>,
- where <type> is one of "lexer", "formatter" or "filter".
- 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:
- continue
- o_args = o_str.split(',')
- for o_arg in o_args:
- o_arg = o_arg.strip()
- try:
- o_key, o_val = o_arg.split('=')
- o_key = o_key.strip()
- o_val = o_val.strip()
- except ValueError:
- opts[o_arg] = True
- else:
- opts[o_key] = o_val
- return opts
- def _parse_filters(f_strs):
- filters = []
- if not f_strs:
- return filters
- for f_str in f_strs:
- if ':' in f_str:
- fname, fopts = f_str.split(':', 1)
- filters.append((fname, _parse_options([fopts])))
- else:
- filters.append((f_str, {}))
- return filters
- def _print_help(what, name):
- try:
- if what == 'lexer':
- cls = find_lexer_class(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:
- print >>sys.stderr, "%s not found!" % what
- def _print_list(what):
- if what == 'lexer':
- print
- print "Lexers:"
- print "~~~~~~~"
- info = []
- for fullname, names, exts, _ in get_all_lexers():
- tup = (', '.join(names)+':', fullname,
- exts and '(filenames ' + ', '.join(exts) + ')' or '')
- info.append(tup)
- info.sort()
- for i in info:
- print ('* %s\n %s %s') % i
- elif what == 'formatter':
- print
- print "Formatters:"
- print "~~~~~~~~~~~"
- info = []
- for cls in get_all_formatters():
- doc = docstring_headline(cls)
- tup = (', '.join(cls.aliases) + ':', doc, cls.filenames and
- '(filenames ' + ', '.join(cls.filenames) + ')' or '')
- info.append(tup)
- info.sort()
- for i in info:
- print ('* %s\n %s %s') % i
- elif what == 'filter':
- print
- print "Filters:"
- print "~~~~~~~~"
- for name in get_all_filters():
- cls = find_filter_class(name)
- print "* " + name + ':'
- print " %s" % docstring_headline(cls)
- elif what == 'style':
- print
- print "Styles:"
- print "~~~~~~~"
- for name in get_all_styles():
- cls = get_style_by_name(name)
- print "* " + name + ':'
- print " %s" % docstring_headline(cls)
- def main(args=sys.argv):
- """
- Main command line entry point.
- """
- # pylint: disable-msg=R0911,R0912,R0915
- usage = USAGE % ((args[0],) * 6)
- try:
- popts, args = getopt.getopt(args[1:], "l:f:F:o:O:P:LS:a:N:hVHg")
- except getopt.GetoptError, err:
- print >>sys.stderr, usage
- return 2
- opts = {}
- O_opts = []
- P_opts = []
- F_opts = []
- for opt, arg in popts:
- if opt == '-O':
- O_opts.append(arg)
- elif opt == '-P':
- P_opts.append(arg)
- elif opt == '-F':
- F_opts.append(arg)
- opts[opt] = arg
- if not opts and not args:
- print usage
- return 0
- 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-2008 by Georg Brandl.' % __version__
- return 0
- # handle ``pygmentize -L``
- L_opt = opts.pop('-L', None)
- if L_opt is not None:
- if opts:
- print >>sys.stderr, usage
- return 2
- # print version
- main(['', '-V'])
- if not args:
- args = ['lexer', 'formatter', 'filter', 'style']
- for arg in args:
- _print_list(arg.rstrip('s'))
- return 0
- # handle ``pygmentize -H``
- H_opt = opts.pop('-H', None)
- if H_opt is not None:
- if opts or len(args) != 2:
- print >>sys.stderr, usage
- return 2
- what, name = args
- if what not in ('lexer', 'formatter', 'filter'):
- print >>sys.stderr, usage
- return 2
- _print_help(what, name)
- return 0
- # parse -O options
- parsed_opts = _parse_options(O_opts)
- opts.pop('-O', None)
- # parse -P options
- for p_opt in P_opts:
- try:
- name, value = p_opt.split('=', 1)
- except ValueError:
- parsed_opts[p_opt] = True
- else:
- parsed_opts[name] = value
- opts.pop('-P', None)
- # handle ``pygmentize -N``
- infn = opts.pop('-N', None)
- if infn is not None:
- try:
- lexer = get_lexer_for_filename(infn, **parsed_opts)
- except ClassNotFound, err:
- lexer = TextLexer()
- except OptionError, err:
- print >>sys.stderr, 'Error:', err
- return 1
- print lexer.aliases[0]
- return 0
- # handle ``pygmentize -S``
- S_opt = opts.pop('-S', None)
- a_opt = opts.pop('-a', None)
- if S_opt is not None:
- f_opt = opts.pop('-f', None)
- if not f_opt:
- print >>sys.stderr, usage
- return 2
- if opts or args:
- print >>sys.stderr, usage
- return 2
- try:
- parsed_opts['style'] = S_opt
- fmter = get_formatter_by_name(f_opt, **parsed_opts)
- except ClassNotFound, err:
- print >>sys.stderr, err
- return 1
- arg = a_opt or ''
- try:
- print fmter.get_style_defs(arg)
- except Exception, err:
- print >>sys.stderr, 'Error:', err
- return 1
- return 0
- # if no -S is given, -a is not allowed
- if a_opt is not None:
- print >>sys.stderr, usage
- return 2
- # parse -F options
- F_opts = _parse_filters(F_opts)
- opts.pop('-F', None)
- # select formatter
- outfn = opts.pop('-o', None)
- fmter = opts.pop('-f', None)
- if fmter:
- try:
- fmter = get_formatter_by_name(fmter, **parsed_opts)
- except (OptionError, ClassNotFound), err:
- print >>sys.stderr, 'Error:', err
- return 1
- if outfn:
- if not fmter:
- try:
- fmter = get_formatter_for_filename(outfn, **parsed_opts)
- except (OptionError, ClassNotFound), err:
- print >>sys.stderr, 'Error:', err
- return 1
- try:
- outfile = open(outfn, 'wb')
- except Exception, err:
- print >>sys.stderr, 'Error: cannot open outfile:', err
- return 1
- else:
- if not fmter:
- fmter = TerminalFormatter(**parsed_opts)
- outfile = sys.stdout
- # select lexer
- lexer = opts.pop('-l', None)
- if lexer:
- try:
- lexer = get_lexer_by_name(lexer, **parsed_opts)
- except (OptionError, ClassNotFound), err:
- print >>sys.stderr, 'Error:', err
- return 1
- if args:
- if len(args) > 1:
- print >>sys.stderr, usage
- return 2
- infn = args[0]
- try:
- code = open(infn, 'rb').read()
- except Exception, err:
- print >>sys.stderr, 'Error: cannot read infile:', err
- return 1
- if not lexer:
- try:
- lexer = get_lexer_for_filename(infn, code, **parsed_opts)
- except ClassNotFound, err:
- if '-g' in opts:
- try:
- lexer = guess_lexer(code)
- except ClassNotFound:
- lexer = TextLexer()
- else:
- print >>sys.stderr, 'Error:', err
- return 1
- except OptionError, err:
- print >>sys.stderr, 'Error:', err
- return 1
- else:
- if '-g' in opts:
- code = sys.stdin.read()
- try:
- lexer = guess_lexer(code)
- except ClassNotFound:
- lexer = TextLexer()
- elif not lexer:
- print >>sys.stderr, 'Error: no lexer name given and reading ' + \
- 'from stdin (try using -g or -l <lexer>)'
- return 2
- else:
- code = sys.stdin.read()
- # No encoding given? Use latin1 if output file given,
- # stdin/stdout encoding otherwise.
- # (This is a compromise, I'm not too happy with it...)
- if 'encoding' not in parsed_opts and 'outencoding' not in parsed_opts:
- if outfn:
- # encoding pass-through
- fmter.encoding = 'latin1'
- else:
- if sys.version_info < (3,):
- # use terminal encoding; Python 3's terminals already do that
- lexer.encoding = getattr(sys.stdin, 'encoding',
- None) or 'ascii'
- fmter.encoding = getattr(sys.stdout, 'encoding',
- None) or 'ascii'
- # ... and do it!
- try:
- # process filters
- for fname, fopts in F_opts:
- lexer.add_filter(fname, **fopts)
- highlight(code, lexer, fmter, outfile)
- except Exception, err:
- 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 >>sys.stderr
- print >>sys.stderr, '*** Error while highlighting:'
- print >>sys.stderr, msg
- return 1
- return 0
|