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

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

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

""" 

    pygments.formatters 

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

 

    Pygments formatters. 

 

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

    :license: BSD, see LICENSE for details. 

""" 

 

import re 

import sys 

import types 

import fnmatch 

from os.path import basename 

 

from pygments.formatters._mapping import FORMATTERS 

from pygments.plugin import find_plugin_formatters 

from pygments.util import ClassNotFound, itervalues 

 

__all__ = ['get_formatter_by_name', 'get_formatter_for_filename', 

           'get_all_formatters'] + list(FORMATTERS) 

 

_formatter_cache = {}  # classes by name 

_pattern_cache = {} 

 

 

def _fn_matches(fn, glob): 

    """Return whether the supplied file name fn matches pattern filename.""" 

    if glob not in _pattern_cache: 

        pattern = _pattern_cache[glob] = re.compile(fnmatch.translate(glob)) 

        return pattern.match(fn) 

    return _pattern_cache[glob].match(fn) 

 

 

def _load_formatters(module_name): 

    """Load a formatter (and all others in the module too).""" 

    mod = __import__(module_name, None, None, ['__all__']) 

    for formatter_name in mod.__all__: 

        cls = getattr(mod, formatter_name) 

        _formatter_cache[cls.name] = cls 

 

 

def get_all_formatters(): 

    """Return a generator for all formatter classes.""" 

    # NB: this returns formatter classes, not info like get_all_lexers(). 

    for info in itervalues(FORMATTERS): 

        if info[1] not in _formatter_cache: 

            _load_formatters(info[0]) 

        yield _formatter_cache[info[1]] 

    for _, formatter in find_plugin_formatters(): 

        yield formatter 

 

 

def find_formatter_class(alias): 

    """Lookup a formatter by alias. 

 

    Returns None if not found. 

    """ 

    for module_name, name, aliases, _, _ in itervalues(FORMATTERS): 

        if alias in aliases: 

            if name not in _formatter_cache: 

                _load_formatters(module_name) 

            return _formatter_cache[name] 

    for _, cls in find_plugin_formatters(): 

        if alias in cls.aliases: 

            return cls 

 

 

def get_formatter_by_name(_alias, **options): 

    """Lookup and instantiate a formatter by alias. 

 

    Raises ClassNotFound if not found. 

    """ 

    cls = find_formatter_class(_alias) 

    if cls is None: 

        raise ClassNotFound("no formatter found for name %r" % _alias) 

    return cls(**options) 

 

 

def get_formatter_for_filename(fn, **options): 

    """Lookup and instantiate a formatter by filename pattern. 

 

    Raises ClassNotFound if not found. 

    """ 

    fn = basename(fn) 

    for modname, name, _, filenames, _ in itervalues(FORMATTERS): 

        for filename in filenames: 

            if _fn_matches(fn, filename): 

                if name not in _formatter_cache: 

                    _load_formatters(modname) 

                return _formatter_cache[name](**options) 

    for cls in find_plugin_formatters(): 

        for filename in cls.filenames: 

            if _fn_matches(fn, filename): 

                return cls(**options) 

    raise ClassNotFound("no formatter found for file name %r" % fn) 

 

 

class _automodule(types.ModuleType): 

    """Automatically import formatters.""" 

 

    def __getattr__(self, name): 

        info = FORMATTERS.get(name) 

        if info: 

            _load_formatters(info[0]) 

            cls = _formatter_cache[info[1]] 

            setattr(self, name, cls) 

            return cls 

        raise AttributeError(name) 

 

 

oldmod = sys.modules[__name__] 

newmod = _automodule(__name__) 

newmod.__dict__.update(oldmod.__dict__) 

sys.modules[__name__] = newmod 

del newmod.newmod, newmod.oldmod, newmod.sys, newmod.types