Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

# -*- coding: utf-8 -*- 

""" 

    pygments.formatter 

    ~~~~~~~~~~~~~~~~~~ 

 

    Base formatter class. 

 

    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS. 

    :license: BSD, see LICENSE for details. 

""" 

 

import codecs 

 

from pygments.util import get_bool_opt, string_types 

from pygments.styles import get_style_by_name 

 

__all__ = ['Formatter'] 

 

 

def _lookup_style(style): 

    if isinstance(style, string_types): 

        return get_style_by_name(style) 

    return style 

 

 

class Formatter(object): 

    """ 

    Converts a token stream to text. 

 

    Options accepted: 

 

    ``style`` 

        The style to use, can be a string or a Style subclass 

        (default: "default"). Not used by e.g. the 

        TerminalFormatter. 

    ``full`` 

        Tells the formatter to output a "full" document, i.e. 

        a complete self-contained document. This doesn't have 

        any effect for some formatters (default: false). 

    ``title`` 

        If ``full`` is true, the title that should be used to 

        caption the document (default: ''). 

    ``encoding`` 

        If given, must be an encoding name. This will be used to 

        convert the Unicode token strings to byte strings in the 

        output. If it is "" or None, Unicode strings will be written 

        to the output file, which most file-like objects do not 

        support (default: None). 

    ``outencoding`` 

        Overrides ``encoding`` if given. 

    """ 

 

    #: Name of the formatter 

    name = None 

 

    #: Shortcuts for the formatter 

    aliases = [] 

 

    #: fn match rules 

    filenames = [] 

 

    #: If True, this formatter outputs Unicode strings when no encoding 

    #: option is given. 

    unicodeoutput = True 

 

    def __init__(self, **options): 

        self.style = _lookup_style(options.get('style', 'default')) 

        self.full  = get_bool_opt(options, 'full', False) 

        self.title = options.get('title', '') 

        self.encoding = options.get('encoding', None) or None 

        if self.encoding in ('guess', 'chardet'): 

            # can happen for e.g. pygmentize -O encoding=guess 

            self.encoding = 'utf-8' 

        self.encoding = options.get('outencoding') or self.encoding 

        self.options = options 

 

    def get_style_defs(self, arg=''): 

        """ 

        Return the style definitions for the current style as a string. 

 

        ``arg`` is an additional argument whose meaning depends on the 

        formatter used. Note that ``arg`` can also be a list or tuple 

        for some formatters like the html formatter. 

        """ 

        return '' 

 

    def format(self, tokensource, outfile): 

        """ 

        Format ``tokensource``, an iterable of ``(tokentype, tokenstring)`` 

        tuples and write it into ``outfile``. 

        """ 

        if self.encoding: 

            # wrap the outfile in a StreamWriter 

            outfile = codecs.lookup(self.encoding)[3](outfile) 

        return self.format_unencoded(tokensource, outfile)