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

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

""" 

    pygments.filter 

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

 

    Module that implements the default filter. 

 

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

    :license: BSD, see LICENSE for details. 

""" 

 

 

def apply_filters(stream, filters, lexer=None): 

    """ 

    Use this method to apply an iterable of filters to 

    a stream. If lexer is given it's forwarded to the 

    filter, otherwise the filter receives `None`. 

    """ 

    def _apply(filter_, stream): 

        for token in filter_.filter(lexer, stream): 

            yield token 

    for filter_ in filters: 

        stream = _apply(filter_, stream) 

    return stream 

 

 

def simplefilter(f): 

    """ 

    Decorator that converts a function into a filter:: 

 

        @simplefilter 

        def lowercase(lexer, stream, options): 

            for ttype, value in stream: 

                yield ttype, value.lower() 

    """ 

    return type(f.__name__, (FunctionFilter,), { 

                'function':     f, 

                '__module__':   getattr(f, '__module__'), 

                '__doc__':      f.__doc__ 

            }) 

 

 

class Filter(object): 

    """ 

    Default filter. Subclass this class or use the `simplefilter` 

    decorator to create own filters. 

    """ 

 

    def __init__(self, **options): 

        self.options = options 

 

    def filter(self, lexer, stream): 

        raise NotImplementedError() 

 

 

class FunctionFilter(Filter): 

    """ 

    Abstract class used by `simplefilter` to create simple 

    function filters on the fly. The `simplefilter` decorator 

    automatically creates subclasses of this class for 

    functions passed to it. 

    """ 

    function = None 

 

    def __init__(self, **options): 

        if not hasattr(self, 'function'): 

            raise TypeError('%r used without bound function' % 

                            self.__class__.__name__) 

        Filter.__init__(self, **options) 

 

    def filter(self, lexer, stream): 

        # pylint: disable-msg=E1102 

        for ttype, value in self.function(lexer, stream, self.options): 

            yield ttype, value