Ejemplo n.º 1
0
    def __init__(self, **options):
        Formatter.__init__(self, **options)
        self.nowrap = get_bool_opt(options, 'nowrap', False)
        self.noclasses = get_bool_opt(options, 'noclasses', False)
        self.classprefix = options.get('classprefix', '')
        self.cssclass = options.get('cssclass', 'highlight')
        self.cssstyles = options.get('cssstyles', '')
        self.prestyles = options.get('prestyles', '')
        self.cssfile = options.get('cssfile', '')
        linenos = options.get('linenos', False)
        if linenos == 'inline':
            self.linenos = 2
        elif linenos:
            # compatibility with <= 0.7
            self.linenos = 1
        else:
            self.linenos = 0
        self.linenostart = abs(get_int_opt(options, 'linenostart', 1))
        self.linenostep = abs(get_int_opt(options, 'linenostep', 1))
        self.linenospecial = abs(get_int_opt(options, 'linenospecial', 0))
        self.nobackground = get_bool_opt(options, 'nobackground', False)
        self.lineseparator = options.get('lineseparator', '\n')
        self.lineanchors = options.get('lineanchors', '')
        self.hl_lines = set()
        for lineno in get_list_opt(options, 'hl_lines', []):
            try:
                self.hl_lines.add(int(lineno))
            except ValueError:
                pass

        self._class_cache = {}
        self._create_stylesheet()
Ejemplo n.º 2
0
    def __init__(self, **options):
        Formatter.__init__(self, **options)
        self._code = get_bool_opt(options, 'codetag', False)
        self._mono = get_bool_opt(options, 'monofont', False)

        self.styles = {}
        self._make_styles()
Ejemplo n.º 3
0
 def __init__(self, **options):
     self.stdlibhighlighting = get_bool_opt(options, 'stdlibhighlighting',
                                            True)
     self.c99highlighting = get_bool_opt(options, 'c99highlighting', True)
     self.platformhighlighting = get_bool_opt(options,
                                              'platformhighlighting', True)
     RegexLexer.__init__(self, **options)
Ejemplo n.º 4
0
 def __init__(self, **options):
     Formatter.__init__(self, **options)
     self.lineseparator = options.get("lineseparator", "\n")
     self.tabwidth = get_int_opt(options, "tabwidth", 4)
     self.escapetable = _escape_html_table
     self.escapetable[ord("\t")] = "&nbsp;" * self.tabwidth
     self.noclasses = get_bool_opt(options, "noclasses", False)
     self.classprefix = options.get("classprefix", "")
     self.cssclass = options.get("cssclass", "highlight")
     self.stylebg = get_bool_opt(options, "stylebg", True)
     self.stylebgalternating = get_bool_opt(options, "stylebgalternating", True)
     self.fontfamily = options.get("fontfamily", "Courier")
     self.fontsize = options.get("fontsize", "1.2em")
     self._create_stylesheet()
     self.linecolwidth = options.get("linecolwidth", 3)
     self.tablewidth = options.get("tablewidth", "100%")
     self.showtitles = get_bool_opt(options, "showtitles", False)
     self.titles = []
     self.additionalstyles = options.get(
         "additionalstyles",
         (
             AspectStyle(name=CSSCLASS_LINENO, styles=dict(bgcolor="eeeeee", borderright="eeaaaa")),
             AspectStyle(name="bgcoloreven", styles=dict(bgcolor="fafafa")),
             AspectStyle(name="bgcoloreven2", styles=dict(bgcolor="fdfdfd")),
             AspectStyle(name="bgcolorodd", styles=dict(bgcolor="f5f5f5")),
             AspectStyle(name="bgcolorodd2", styles=dict(bgcolor="f8f8f8")),
             AspectStyle(name=CSSCLASS_TD_TITLE, styles=dict(bgcolor="eeaaaa", paddingleft="15px")),
         ),
     )
     self._create_additional_styles()
Ejemplo n.º 5
0
Archivo: bbcode.py Proyecto: 10sr/hue
    def __init__(self, **options):
        Formatter.__init__(self, **options)
        self._code = get_bool_opt(options, 'codetag', False)
        self._mono = get_bool_opt(options, 'monofont', False)

        self.styles = {}
        self._make_styles()
Ejemplo n.º 6
0
 def __init__(self, **options):
     """
     See the class docstring for explanation of options.
     """
     if not pil_available:
         raise PilNotAvailable(
             'Python Imaging Library is required for this formatter')
     Formatter.__init__(self, **options)
     self.encoding = 'latin1'  # let pygments.format() do the right thing
     # Read the style
     self.styles = dict(self.style)
     if self.style.background_color is None:
         self.background_color = '#fff'
     else:
         self.background_color = self.style.background_color
     # Image options
     self.image_format = get_choice_opt(options,
                                        'image_format',
                                        ['png', 'jpeg', 'gif', 'bmp'],
                                        self.default_image_format,
                                        normcase=True)
     self.image_pad = get_int_opt(options, 'image_pad', 10)
     self.line_pad = get_int_opt(options, 'line_pad', 2)
     # The fonts
     fontsize = get_int_opt(options, 'font_size', 14)
     self.fonts = FontManager(options.get('font_name', ''), fontsize)
     self.fontw, self.fonth = self.fonts.get_char_size()
     # Line number options
     self.line_number_fg = options.get('line_number_fg', '#886')
     self.line_number_bg = options.get('line_number_bg', '#eed')
     self.line_number_chars = get_int_opt(options, 'line_number_chars', 2)
     self.line_number_bold = get_bool_opt(options, 'line_number_bold',
                                          False)
     self.line_number_italic = get_bool_opt(options, 'line_number_italic',
                                            False)
     self.line_number_pad = get_int_opt(options, 'line_number_pad', 6)
     self.line_numbers = get_bool_opt(options, 'line_numbers', True)
     self.line_number_separator = get_bool_opt(options,
                                               'line_number_separator',
                                               True)
     self.line_number_step = get_int_opt(options, 'line_number_step', 1)
     self.line_number_start = get_int_opt(options, 'line_number_start', 1)
     if self.line_numbers:
         self.line_number_width = (self.fontw * self.line_number_chars +
                                   self.line_number_pad * 2)
     else:
         self.line_number_width = 0
     self.hl_lines = []
     hl_lines_str = get_list_opt(options, 'hl_lines', [])
     for line in hl_lines_str:
         try:
             self.hl_lines.append(int(line))
         except ValueError:
             pass
     self.hl_color = options.get('hl_color',
                                 self.style.highlight_color) or '#f90'
     self.drawables = []
Ejemplo n.º 7
0
 def __init__(self, **options):
     self.options = options
     self.stripnl = get_bool_opt(options, 'stripnl', True)
     self.stripall = get_bool_opt(options, 'stripall', False)
     self.tabsize = get_int_opt(options, 'tabsize', 0)
     self.encoding = options.get('encoding', 'latin1')
     # self.encoding = options.get('inencoding', None) or self.encoding
     self.filters = []
     for filter_ in get_list_opt(options, 'filters', ()):
         self.add_filter(filter_)
Ejemplo n.º 8
0
 def __init__(self, **options):
     self.options = options
     self.stripnl = get_bool_opt(options, 'stripnl', True)
     self.stripall = get_bool_opt(options, 'stripall', False)
     self.tabsize = get_int_opt(options, 'tabsize', 0)
     self.encoding = options.get('encoding', 'latin1')
     # self.encoding = options.get('inencoding', None) or self.encoding
     self.filters = []
     for filter_ in get_list_opt(options, 'filters', ()):
         self.add_filter(filter_)
Ejemplo n.º 9
0
 def __init__(self, **options):
     """
     See the class docstring for explanation of options.
     """
     if not pil_available:
         raise PilNotAvailable(
             'Python Imaging Library is required for this formatter')
     Formatter.__init__(self, **options)
     self.encoding = 'latin1'  # let pygments.format() do the right thing
     # Read the style
     self.styles = dict(self.style)
     if self.style.background_color is None:
         self.background_color = '#fff'
     else:
         self.background_color = self.style.background_color
     # Image options
     self.image_format = get_choice_opt(
         options, 'image_format', ['png', 'jpeg', 'gif', 'bmp'],
         self.default_image_format, normcase=True)
     self.image_pad = get_int_opt(options, 'image_pad', 10)
     self.line_pad = get_int_opt(options, 'line_pad', 2)
     # The fonts
     fontsize = get_int_opt(options, 'font_size', 14)
     self.fonts = FontManager(options.get('font_name', ''), fontsize)
     self.fontw, self.fonth = self.fonts.get_char_size()
     # Line number options
     self.line_number_fg = options.get('line_number_fg', '#886')
     self.line_number_bg = options.get('line_number_bg', '#eed')
     self.line_number_chars = get_int_opt(options,
                                          'line_number_chars', 2)
     self.line_number_bold = get_bool_opt(options,
                                          'line_number_bold', False)
     self.line_number_italic = get_bool_opt(options,
                                            'line_number_italic', False)
     self.line_number_pad = get_int_opt(options, 'line_number_pad', 6)
     self.line_numbers = get_bool_opt(options, 'line_numbers', True)
     self.line_number_separator = get_bool_opt(options,
                                               'line_number_separator', True)
     self.line_number_step = get_int_opt(options, 'line_number_step', 1)
     self.line_number_start = get_int_opt(options, 'line_number_start', 1)
     if self.line_numbers:
         self.line_number_width = (self.fontw * self.line_number_chars +
                                   self.line_number_pad * 2)
     else:
         self.line_number_width = 0
     self.hl_lines = []
     hl_lines_str = get_list_opt(options, 'hl_lines', [])
     for line in hl_lines_str:
         try:
             self.hl_lines.append(int(line))
         except ValueError:
             pass
     self.hl_color = options.get('hl_color',
                                 self.style.highlight_color) or '#f90'
     self.drawables = []
Ejemplo n.º 10
0
 def __init__(self, **options):
     self.options = options
     self.stripnl = get_bool_opt(options, "stripnl", True)
     self.stripall = get_bool_opt(options, "stripall", False)
     self.ensurenl = get_bool_opt(options, "ensurenl", True)
     self.tabsize = get_int_opt(options, "tabsize", 0)
     self.encoding = options.get("encoding", "utf-8")
     # self.encoding = options.get('inencoding', None) or self.encoding
     self.filters = []
     for filter_ in get_list_opt(options, "filters", ()):
         self.add_filter(filter_)
Ejemplo n.º 11
0
    def __init__(self, **options):
        Formatter.__init__(self, **options)

        self.monospaced = get_bool_opt(options, 'monospaced', True)
        self.linenos = get_bool_opt(options, 'linenos', False)
        self._lineno = 0
        self.wrap = get_int_opt(options, 'wrap', 0)
        self._linelen = 0

        self.styles = {}
        self._make_styles()
Ejemplo n.º 12
0
    def __init__(self, **options):
        Formatter.__init__(self, **options)
        self.docclass = options.get('docclass', 'article')
        self.preamble = options.get('preamble', '')
        self.linenos = get_bool_opt(options, 'linenos', False)
        self.linenostart = abs(get_int_opt(options, 'linenostart', 1))
        self.linenostep = abs(get_int_opt(options, 'linenostep', 1))
        self.verboptions = options.get('verboptions', '')
        self.nobackground = get_bool_opt(options, 'nobackground', False)
        self.commandprefix = options.get('commandprefix', 'PY')

        self._create_stylecmds()
Ejemplo n.º 13
0
    def __init__(self, **options):
        Formatter.__init__(self, **options)
        self.docclass = options.get('docclass', 'article')
        self.preamble = options.get('preamble', '')
        self.linenos = get_bool_opt(options, 'linenos', False)
        self.linenostart = abs(get_int_opt(options, 'linenostart', 1))
        self.linenostep = abs(get_int_opt(options, 'linenostep', 1))
        self.verboptions = options.get('verboptions', '')
        self.nobackground = get_bool_opt(options, 'nobackground', False)
        self.commandprefix = options.get('commandprefix', 'PY')

        self._create_stylecmds()
Ejemplo n.º 14
0
 def __init__(self, **options):
     Lexer.__init__(self, **options)
     self.keywords = set()
     if get_bool_opt(options, 'turbopascal', True):
         self.keywords.update(self.TURBO_PASCAL_KEYWORDS)
     if get_bool_opt(options, 'delphi', True):
         self.keywords.update(self.DELPHI_KEYWORDS)
     if get_bool_opt(options, 'freepascal', True):
         self.keywords.update(self.FREE_PASCAL_KEYWORDS)
     self.builtins = set()
     for unit in get_list_opt(options, 'units', list(self.BUILTIN_UNITS)):
         self.builtins.update(self.BUILTIN_UNITS[unit])
Ejemplo n.º 15
0
    def __init__(self, **options):
        Formatter.__init__(self, **options)
        self.docclass = options.get("docclass", "article")
        self.preamble = options.get("preamble", "")
        self.linenos = get_bool_opt(options, "linenos", False)
        self.linenostart = abs(get_int_opt(options, "linenostart", 1))
        self.linenostep = abs(get_int_opt(options, "linenostep", 1))
        self.verboptions = options.get("verboptions", "")
        self.nobackground = get_bool_opt(options, "nobackground", False)
        self.commandprefix = options.get("commandprefix", "PY")

        self._create_stylecmds()
Ejemplo n.º 16
0
 def __init__(self, **options):
     Lexer.__init__(self, **options)
     self.keywords = set()
     if get_bool_opt(options, 'turbopascal', True):
         self.keywords.update(self.TURBO_PASCAL_KEYWORDS)
     if get_bool_opt(options, 'delphi', True):
         self.keywords.update(self.DELPHI_KEYWORDS)
     if get_bool_opt(options, 'freepascal', True):
         self.keywords.update(self.FREE_PASCAL_KEYWORDS)
     self.builtins = set()
     for unit in get_list_opt(options, 'units', list(self.BUILTIN_UNITS)):
         self.builtins.update(self.BUILTIN_UNITS[unit])
Ejemplo n.º 17
0
    def __init__(self, **options):
        self.builtinshighlighting = get_bool_opt(options, "builtinshighlighting", True)
        self.requiredelimiters = get_bool_opt(options, "requiredelimiters", False)

        self._builtins = set()
        self._members = set()
        if self.builtinshighlighting:
            from pygments.lexers._lasso_builtins import BUILTINS, MEMBERS

            for key, value in iteritems(BUILTINS):
                self._builtins.update(value)
            for key, value in iteritems(MEMBERS):
                self._members.update(value)
        RegexLexer.__init__(self, **options)
Ejemplo n.º 18
0
    def __init__(self, **options):
        Formatter.__init__(self, **options)
        self.title = self._decodeifneeded(self.title)
        self.nowrap = get_bool_opt(options, 'nowrap', False)
        self.noclasses = get_bool_opt(options, 'noclasses', False)
        self.classprefix = options.get('classprefix', '')
        self.cssclass = self._decodeifneeded(
            options.get('cssclass', 'highlight'))
        self.cssstyles = self._decodeifneeded(options.get('cssstyles', ''))
        self.prestyles = self._decodeifneeded(options.get('prestyles', ''))
        self.cssfile = self._decodeifneeded(options.get('cssfile', ''))
        self.noclobber_cssfile = get_bool_opt(options, 'noclobber_cssfile',
                                              False)
        self.tagsfile = self._decodeifneeded(options.get('tagsfile', ''))
        self.tagurlformat = self._decodeifneeded(
            options.get('tagurlformat', ''))
        self.filename = self._decodeifneeded(options.get('filename', ''))
        self.wrapcode = get_bool_opt(options, 'wrapcode', False)

        if self.tagsfile:
            if not ctags:
                raise RuntimeError('The "ctags" package must to be installed '
                                   'to be able to use the "tagsfile" feature.')
            self._ctags = ctags.CTags(self.tagsfile)

        linenos = options.get('linenos', False)
        if linenos == 'inline':
            self.linenos = 2
        elif linenos:
            # compatibility with <= 0.7
            self.linenos = 1
        else:
            self.linenos = 0
        self.linenostart = abs(get_int_opt(options, 'linenostart', 1))
        self.linenostep = abs(get_int_opt(options, 'linenostep', 1))
        self.linenospecial = abs(get_int_opt(options, 'linenospecial', 0))
        self.nobackground = get_bool_opt(options, 'nobackground', False)
        self.lineseparator = options.get('lineseparator', u'\n')
        self.lineanchors = options.get('lineanchors', '')
        self.linespans = options.get('linespans', '')
        self.anchorlinenos = options.get('anchorlinenos', False)
        self.hl_lines = set()
        for lineno in get_list_opt(options, 'hl_lines', []):
            try:
                self.hl_lines.add(int(lineno))
            except ValueError:
                pass
        self.hl_words = options.get('hl_words', {})

        self._create_stylesheet()
Ejemplo n.º 19
0
    def __init__(self, **options):
        Formatter.__init__(self, **options)
        self.docclass = options.get('docclass', 'article')
        self.preamble = options.get('preamble', '')
        self.linenos = get_bool_opt(options, 'linenos', False)
        self.linenostart = abs(get_int_opt(options, 'linenostart', 1))
        self.linenostep = abs(get_int_opt(options, 'linenostep', 1))
        self.verboptions = options.get('verboptions', '')
        self.nobackground = get_bool_opt(options, 'nobackground', False)
        self.commandprefix = options.get('commandprefix', 'PY')
        self.texcomments = get_bool_opt(options, 'texcomments', False)
        self.mathescape = get_bool_opt(options, 'mathescape', False)
	self.highlights = get_list_opt(options, 'highlights', [])
        self._create_stylesheet()
Ejemplo n.º 20
0
    def __init__(self, **options):
        self.builtinshighlighting = get_bool_opt(
            options, 'builtinshighlighting', True)
        self.requiredelimiters = get_bool_opt(
            options, 'requiredelimiters', False)

        self._builtins = set()
        self._members = set()
        if self.builtinshighlighting:
            from pygments.lexers._lasso_builtins import BUILTINS, MEMBERS
            for key, value in iteritems(BUILTINS):
                self._builtins.update(value)
            for key, value in iteritems(MEMBERS):
                self._members.update(value)
        RegexLexer.__init__(self, **options)
Ejemplo n.º 21
0
 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
     self.encoding = options.get("outencoding", None) or self.encoding
     self.options = options
Ejemplo n.º 22
0
    def __init__(self, **options):
        """
        Additional options accepted:

        ``fontface``
            Name of the font used. Could for example be ``'Courier New'``
            to further specify the default which is ``'\fmodern'``. The RTF
            specification claims that ``\fmodern`` are "Fixed-pitch serif
            and sans serif fonts". Hope every RTF implementation thinks
            the same about modern...
        """
        Formatter.__init__(self, **options)
        self.fontface = options.get('fontface') or ''
        # New options added with cilkhilite pygments plugin
        self.hidebydefault = get_bool_opt(options, 'hidebydefault', False)
        self.reindent = get_bool_opt(options, 'reindent', False)
Ejemplo n.º 23
0
 def __init__(self, **options):
     Formatter.__init__(self, **options)
     self.nowrap = get_bool_opt(options, 'nowrap', False)
     self.fontfamily = options.get('fontfamily', 'monospace')
     self.fontsize = options.get('fontsize', '14px')
     self.xoffset = get_int_opt(options, 'xoffset', 0)
     fs = self.fontsize.strip()
     if fs.endswith('px'): fs = fs[:-2].strip()
     try:
         int_fs = int(fs)
     except:
         int_fs = 20
     self.yoffset = get_int_opt(options, 'yoffset', int_fs)
     self.ystep = get_int_opt(options, 'ystep', int_fs + 5)
     self.spacehack = get_bool_opt(options, 'spacehack', True)
     self._stylecache = {}
Ejemplo n.º 24
0
 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
     self.encoding = options.get('outencoding', None) or self.encoding
     self.options = options
Ejemplo n.º 25
0
 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
     self.encoding = options.get('outencoding', None) or self.encoding
     self.options = options
Ejemplo n.º 26
0
 def __init__(self, **options):
     Formatter.__init__(self, **options)
     self.nowrap = get_bool_opt(options, 'nowrap', False)
     self.fontfamily = options.get('fontfamily', 'monospace')
     self.fontsize = options.get('fontsize', '14px')
     self.xoffset = get_int_opt(options, 'xoffset', 0)
     fs = self.fontsize.strip()
     if fs.endswith('px'): fs = fs[:-2].strip()
     try:
         int_fs = int(fs)
     except:
         int_fs = 20
     self.yoffset = get_int_opt(options, 'yoffset', int_fs)
     self.ystep = get_int_opt(options, 'ystep', int_fs + 5)
     self.spacehack = get_bool_opt(options, 'spacehack', True)
     self._stylecache = {}
Ejemplo n.º 27
0
 def __init__(self, **options):
     """
     See the class docstring for explanation of options.
     """
     if not pil_available:
         raise PilNotAvailable("Python Imaging Library is required for this formatter")
     Formatter.__init__(self, **options)
     # Read the style
     self.styles = dict(self.style)
     if self.style.background_color is None:
         self.background_color = "#fff"
     else:
         self.background_color = self.style.background_color
     # Image options
     self.image_format = get_choice_opt(
         options, "image_format", ["png", "jpeg", "gif", "bmp"], self.default_image_format, normcase=True
     )
     self.image_pad = get_int_opt(options, "image_pad", 10)
     self.line_pad = get_int_opt(options, "line_pad", 2)
     # The fonts
     fontsize = get_int_opt(options, "font_size", 14)
     self.fonts = FontManager(options.get("font_name", ""), fontsize)
     self.fontw, self.fonth = self.fonts.get_char_size()
     # Line number options
     self.line_number_fg = options.get("line_number_fg", "#886")
     self.line_number_bg = options.get("line_number_bg", "#eed")
     self.line_number_chars = get_int_opt(options, "line_number_chars", 2)
     self.line_number_bold = get_bool_opt(options, "line_number_bold", False)
     self.line_number_italic = get_bool_opt(options, "line_number_italic", False)
     self.line_number_pad = get_int_opt(options, "line_number_pad", 6)
     self.line_numbers = get_bool_opt(options, "line_numbers", True)
     self.line_number_separator = get_bool_opt(options, "line_number_separator", True)
     self.line_number_step = get_int_opt(options, "line_number_step", 1)
     self.line_number_start = get_int_opt(options, "line_number_start", 1)
     if self.line_numbers:
         self.line_number_width = self.fontw * self.line_number_chars + self.line_number_pad * 2
     else:
         self.line_number_width = 0
     self.hl_lines = []
     hl_lines_str = get_list_opt(options, "hl_lines", [])
     for line in hl_lines_str:
         try:
             self.hl_lines.append(int(line))
         except ValueError:
             pass
     self.hl_color = options.get("hl_color", self.style.highlight_color) or "#f90"
     self.drawables = []
Ejemplo n.º 28
0
    def __init__(self, **options):
        Formatter.__init__(self, **options)
        self.title = self._decodeifneeded(self.title)
        self.nowrap = get_bool_opt(options, 'nowrap', False)
        self.noclasses = get_bool_opt(options, 'noclasses', False)
        self.classprefix = options.get('classprefix', '')
        self.cssclass = self._decodeifneeded(options.get('cssclass', 'highlight'))
        self.cssstyles = self._decodeifneeded(options.get('cssstyles', ''))
        self.prestyles = self._decodeifneeded(options.get('prestyles', ''))
        self.cssfile = self._decodeifneeded(options.get('cssfile', ''))
        self.noclobber_cssfile = get_bool_opt(options, 'noclobber_cssfile', False)
        self.tagsfile = self._decodeifneeded(options.get('tagsfile', ''))
        self.tagurlformat = self._decodeifneeded(options.get('tagurlformat', ''))
        self.filename = self._decodeifneeded(options.get('filename', ''))
        self.wrapcode = get_bool_opt(options, 'wrapcode', False)

        if self.tagsfile:
            if not ctags:
                raise RuntimeError('The "ctags" package must to be installed '
                                   'to be able to use the "tagsfile" feature.')
            self._ctags = ctags.CTags(self.tagsfile)

        linenos = options.get('linenos', False)
        if linenos == 'inline':
            self.linenos = 2
        elif linenos:
            # compatibility with <= 0.7
            self.linenos = 1
        else:
            self.linenos = 0
        self.linenostart = abs(get_int_opt(options, 'linenostart', 1))
        self.linenostep = abs(get_int_opt(options, 'linenostep', 1))
        self.linenospecial = abs(get_int_opt(options, 'linenospecial', 0))
        self.nobackground = get_bool_opt(options, 'nobackground', False)
        self.lineseparator = options.get('lineseparator', '\n')
        self.lineanchors = options.get('lineanchors', '')
        self.linespans = options.get('linespans', '')
        self.anchorlinenos = options.get('anchorlinenos', False)
        self.hl_lines = set()
        for lineno in get_list_opt(options, 'hl_lines', []):
            try:
                self.hl_lines.add(int(lineno))
            except ValueError:
                pass

        self._create_stylesheet()
Ejemplo n.º 29
0
 def __init__(self, **options):
     """
     See the class docstring for explanation of options.
     """
     if not pil_available:
         raise PilNotAvailable(
             'Python Imaging Library is required for this formatter')
     Formatter.__init__(self, **options)
     # Read the style
     self.styles = dict(self.style)
     if self.style.background_color is None:
         self.background_color = '#fff'
     else:
         self.background_color = self.style.background_color
     # Image options
     self.image_format = get_choice_opt(options,
                                        'image_format',
                                        ['png', 'jpeg', 'gif', 'bmp'],
                                        self.default_image_format,
                                        normcase=True)
     self.image_pad = get_int_opt(options, 'image_pad', 10)
     self.line_pad = get_int_opt(options, 'line_pad', 2)
     # The fonts
     fontsize = get_int_opt(options, 'font_size', 14)
     self.fonts = FontManager(options.get('font_name', ''), fontsize)
     self.fontw, self.fonth = self.fonts.get_char_size()
     # Line number options
     self.line_number_fg = options.get('line_number_fg', '#886')
     self.line_number_bg = options.get('line_number_bg', '#eed')
     self.line_number_chars = get_int_opt(options, 'line_number_chars', 2)
     self.line_number_bold = get_bool_opt(options, 'line_number_bold',
                                          False)
     self.line_number_italic = get_bool_opt(options, 'line_number_italic',
                                            False)
     self.line_number_pad = get_int_opt(options, 'line_number_pad', 6)
     self.line_numbers = get_bool_opt(options, 'line_numbers', True)
     self.line_number_separator = get_bool_opt(options,
                                               'line_number_separator',
                                               True)
     self.line_number_step = get_int_opt(options, 'line_number_step', 1)
     if self.line_numbers:
         self.line_number_width = (self.fontw * self.line_number_chars +
                                   self.line_number_pad * 2)
     else:
         self.line_number_width = 0
     self.drawables = []
Ejemplo n.º 30
0
    def __init__(self, **options):
        self.smhighlighting = get_bool_opt(options, 'sourcemod', True)

        self._functions = set()
        if self.smhighlighting:
            from pygments.lexers._sourcemod_builtins import FUNCTIONS
            self._functions.update(FUNCTIONS)
        RegexLexer.__init__(self, **options)
Ejemplo n.º 31
0
    def __init__(self, **options):
        Formatter.__init__(self, **options)
        self.title = self._decodeifneeded(self.title)
        self.nowrap = get_bool_opt(options, "nowrap", False)
        self.noclasses = get_bool_opt(options, "noclasses", False)
        self.classprefix = options.get("classprefix", "")
        self.cssclass = self._decodeifneeded(options.get("cssclass", "highlight"))
        self.cssstyles = self._decodeifneeded(options.get("cssstyles", ""))
        self.prestyles = self._decodeifneeded(options.get("prestyles", ""))
        self.cssfile = self._decodeifneeded(options.get("cssfile", ""))
        self.noclobber_cssfile = get_bool_opt(options, "noclobber_cssfile", False)
        self.tagsfile = self._decodeifneeded(options.get("tagsfile", ""))
        self.tagurlformat = self._decodeifneeded(options.get("tagurlformat", ""))

        if self.tagsfile:
            if not ctags:
                raise RuntimeError(
                    'The "ctags" package must to be installed ' 'to be able to use the "tagsfile" feature.'
                )
            self._ctags = ctags.CTags(self.tagsfile)

        linenos = options.get("linenos", False)
        if linenos == "inline":
            self.linenos = 2
        elif linenos:
            # compatibility with <= 0.7
            self.linenos = 1
        else:
            self.linenos = 0
        self.linenostart = abs(get_int_opt(options, "linenostart", 1))
        self.linenostep = abs(get_int_opt(options, "linenostep", 1))
        self.linenospecial = abs(get_int_opt(options, "linenospecial", 0))
        self.nobackground = get_bool_opt(options, "nobackground", False)
        self.lineseparator = options.get("lineseparator", "\n")
        self.lineanchors = options.get("lineanchors", "")
        self.linespans = options.get("linespans", "")
        self.anchorlinenos = options.get("anchorlinenos", False)
        self.hl_lines = set()
        for lineno in get_list_opt(options, "hl_lines", []):
            try:
                self.hl_lines.add(int(lineno))
            except ValueError:
                pass

        self._create_stylesheet()
Ejemplo n.º 32
0
    def test_getoptions(self):
        raises = self.assertRaises
        equals = self.assertEqual

        equals(util.get_bool_opt({}, "a", True), True)
        equals(util.get_bool_opt({}, "a", 1), True)
        equals(util.get_bool_opt({}, "a", "true"), True)
        equals(util.get_bool_opt({}, "a", "no"), False)
        raises(util.OptionError, util.get_bool_opt, {}, "a", [])
        raises(util.OptionError, util.get_bool_opt, {}, "a", "foo")

        equals(util.get_int_opt({}, "a", 1), 1)
        raises(util.OptionError, util.get_int_opt, {}, "a", [])
        raises(util.OptionError, util.get_int_opt, {}, "a", "bar")

        equals(util.get_list_opt({}, "a", [1]), [1])
        equals(util.get_list_opt({}, "a", "1 2"), ["1", "2"])
        raises(util.OptionError, util.get_list_opt, {}, "a", 1)
Ejemplo n.º 33
0
    def test_getoptions(self):
        raises = self.assertRaises
        equals = self.assertEqual

        equals(util.get_bool_opt({}, 'a', True), True)
        equals(util.get_bool_opt({}, 'a', 1), True)
        equals(util.get_bool_opt({}, 'a', 'true'), True)
        equals(util.get_bool_opt({}, 'a', 'no'), False)
        raises(util.OptionError, util.get_bool_opt, {}, 'a', [])
        raises(util.OptionError, util.get_bool_opt, {}, 'a', 'foo')

        equals(util.get_int_opt({}, 'a', 1), 1)
        raises(util.OptionError, util.get_int_opt, {}, 'a', [])
        raises(util.OptionError, util.get_int_opt, {}, 'a', 'bar')

        equals(util.get_list_opt({}, 'a', [1]), [1])
        equals(util.get_list_opt({}, 'a', '1 2'), ['1', '2'])
        raises(util.OptionError, util.get_list_opt, {}, 'a', 1)
Ejemplo n.º 34
0
    def __init__(self, **options):
        self.smhighlighting = get_bool_opt(options,
                                           'sourcemod', True)

        self._functions = set()
        if self.smhighlighting:
            from pygments.lexers._sourcemodbuiltins import FUNCTIONS
            self._functions.update(FUNCTIONS)
        RegexLexer.__init__(self, **options)
Ejemplo n.º 35
0
    def __init__(self, **options):
        self.funcnamehighlighting = get_bool_opt(options, "funcnamehighlighting", True)
        self.disabledmodules = get_list_opt(options, "disabledmodules", ["unknown"])
        self.startinline = get_bool_opt(options, "startinline", False)

        # private option argument for the lexer itself
        if "_startinline" in options:
            self.startinline = options.pop("_startinline")

        # collect activated functions in a set
        self._functions = set()
        if self.funcnamehighlighting:
            from pygments.lexers._phpbuiltins import MODULES

            for key, value in MODULES.iteritems():
                if key not in self.disabledmodules:
                    self._functions.update(value)
        RegexLexer.__init__(self, **options)
Ejemplo n.º 36
0
 def __init__(self, **options):
     # XXX outencoding
     Formatter.__init__(self, **options)
     self.nowrap = get_bool_opt(options, "nowrap", False)
     self.fontfamily = options.get("fontfamily", "monospace")
     self.fontsize = options.get("fontsize", "14px")
     self.xoffset = get_int_opt(options, "xoffset", 0)
     fs = self.fontsize.strip()
     if fs.endswith("px"):
         fs = fs[:-2].strip()
     try:
         int_fs = int(fs)
     except:
         int_fs = 20
     self.yoffset = get_int_opt(options, "yoffset", int_fs)
     self.ystep = get_int_opt(options, "ystep", int_fs + 5)
     self.spacehack = get_bool_opt(options, "spacehack", True)
     self._stylecache = {}
Ejemplo n.º 37
0
    def test_getoptions(self):
        raises = self.assertRaises
        equals = self.assertEquals

        equals(util.get_bool_opt({}, 'a', True), True)
        equals(util.get_bool_opt({}, 'a', 1), True)
        equals(util.get_bool_opt({}, 'a', 'true'), True)
        equals(util.get_bool_opt({}, 'a', 'no'), False)
        raises(util.OptionError, util.get_bool_opt, {}, 'a', [])
        raises(util.OptionError, util.get_bool_opt, {}, 'a', 'foo')

        equals(util.get_int_opt({}, 'a', 1), 1)
        raises(util.OptionError, util.get_int_opt, {}, 'a', [])
        raises(util.OptionError, util.get_int_opt, {}, 'a', 'bar')

        equals(util.get_list_opt({}, 'a', [1]), [1])
        equals(util.get_list_opt({}, 'a', '1 2'), ['1', '2'])
        raises(util.OptionError, util.get_list_opt, {}, 'a', 1)
Ejemplo n.º 38
0
 def __init__(self, **options):
     """
     See the class docstring for explanation of options.
     """
     if not pil_available:
         raise PilNotAvailable(
             'Python Imaging Library is required for this formatter')
     Formatter.__init__(self, **options)
     # Read the style
     self.styles = dict(self.style)
     if self.style.background_color is None:
         self.background_color = '#fff'
     else:
         self.background_color = self.style.background_color
     # Image options
     self.image_format = get_choice_opt(
         options, 'image_format', ['png', 'jpeg', 'gif', 'bmp'],
         self.default_image_format, normcase=True)
     self.image_pad = get_int_opt(options, 'image_pad', 10)
     self.line_pad = get_int_opt(options, 'line_pad', 2)
     # The fonts
     fontsize = get_int_opt(options, 'font_size', 14)
     self.fonts = FontManager(options.get('font_name', ''), fontsize)
     self.fontw, self.fonth = self.fonts.get_char_size()
     # Line number options
     self.line_number_fg = options.get('line_number_fg', '#886')
     self.line_number_bg = options.get('line_number_bg', '#eed')
     self.line_number_chars = get_int_opt(options,
                                     'line_number_chars', 2)
     self.line_number_bold = get_bool_opt(options,
                                     'line_number_bold', False)
     self.line_number_italic = get_bool_opt(options,
                                     'line_number_italic', False)
     self.line_number_pad = get_int_opt(options, 'line_number_pad', 6)
     self.line_numbers = get_bool_opt(options, 'line_numbers', True)
     self.line_number_separator = get_bool_opt(options,
                                     'line_number_separator', True)
     self.line_number_step = get_int_opt(options, 'line_number_step', 1)
     if self.line_numbers:
         self.line_number_width = (self.fontw * self.line_number_chars +
                                self.line_number_pad * 2)
     else:
         self.line_number_width = 0
     self.drawables = []
Ejemplo n.º 39
0
 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
Ejemplo n.º 40
0
    def __init__(self, **options):
        self.funcnamehighlighting = get_bool_opt(options,
                                                 'funcnamehighlighting', True)
        self.disabledmodules = get_list_opt(options, 'disabledmodules',
                                            ['unknown'])
        self.startinline = get_bool_opt(options, 'startinline', False)

        # private option argument for the lexer itself
        if '_startinline' in options:
            self.startinline = options.pop('_startinline')

        # collect activated functions in a set
        self._functions = set()
        if self.funcnamehighlighting:
            from pygments.lexers._php_builtins import MODULES
            for key, value in MODULES.items():
                if key not in self.disabledmodules:
                    self._functions.update(value)
        RegexLexer.__init__(self, **options)
Ejemplo n.º 41
0
 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 == 'guess':
         # can happen for pygmentize -O encoding=guess
         self.encoding = 'utf-8'
     self.encoding = options.get('outencoding', None) or self.encoding
     self.options = options
Ejemplo n.º 42
0
Archivo: php.py Proyecto: axil/blog
    def __init__(self, **options):
        self.funcnamehighlighting = get_bool_opt(
            options, 'funcnamehighlighting', True)
        self.disabledmodules = get_list_opt(
            options, 'disabledmodules', ['unknown'])
        self.startinline = get_bool_opt(options, 'startinline', False)

        # private option argument for the lexer itself
        if '_startinline' in options:
            self.startinline = options.pop('_startinline')

        # collect activated functions in a set
        self._functions = set()
        if self.funcnamehighlighting:
            from pygments.lexers._php_builtins import MODULES
            for key, value in iteritems(MODULES):
                if key not in self.disabledmodules:
                    self._functions.update(value)
        RegexLexer.__init__(self, **options)
Ejemplo n.º 43
0
def test_getoptions():
    assert util.get_bool_opt({}, 'a', True) is True
    assert util.get_bool_opt({}, 'a', 1) is True
    assert util.get_bool_opt({}, 'a', 'true') is True
    assert util.get_bool_opt({}, 'a', 'no') is False
    assert raises(util.OptionError, util.get_bool_opt, {}, 'a', [])
    assert raises(util.OptionError, util.get_bool_opt, {}, 'a', 'foo')

    assert util.get_int_opt({}, 'a', 1) == 1
    assert raises(util.OptionError, util.get_int_opt, {}, 'a', [])
    assert raises(util.OptionError, util.get_int_opt, {}, 'a', 'bar')

    assert util.get_list_opt({}, 'a', [1]) == [1]
    assert util.get_list_opt({}, 'a', '1 2') == ['1', '2']
    assert raises(util.OptionError, util.get_list_opt, {}, 'a', 1)

    assert util.get_choice_opt({}, 'a', ['foo', 'bar'], 'bar') == 'bar'
    assert util.get_choice_opt({}, 'a', ['foo', 'bar'], 'Bar', True) == 'bar'
    assert raises(util.OptionError, util.get_choice_opt, {}, 'a',
                  ['foo', 'bar'], 'baz')
Ejemplo n.º 44
0
    def __init__(self, **options):
        self.python3 = get_bool_opt(options, "python3", False)
        if self.python3:
            self.aliases = ["ipy3"]
        else:
            self.aliases = ["ipy2", "ipy"]

        Lexer.__init__(self, **options)

        self.IPythonLexer = IPythonLexer(**options)
        self.IPythonConsoleLexer = IPythonConsoleLexer(**options)
Ejemplo n.º 45
0
    def __init__(self, **options):
        self.python3 = get_bool_opt(options, 'python3', False)
        if self.python3:
            self.aliases = ['ipy3']
        else:
            self.aliases = ['ipy2', 'ipy']

        Lexer.__init__(self, **options)

        self.IPythonLexer = IPythonLexer(**options)
        self.IPythonConsoleLexer = IPythonConsoleLexer(**options)
    def __init__(self, **options):
        self.python3 = get_bool_opt(options, 'python3', False)
        if self.python3:
            self.aliases = ['ipy3']
        else:
            self.aliases = ['ipy2', 'ipy']

        Lexer.__init__(self, **options)

        self.IPythonLexer = IPythonLexer(**options)
        self.IPythonConsoleLexer = IPythonConsoleLexer(**options)
Ejemplo n.º 47
0
    def __init__(self, **options):
        self.func_name_highlighting = get_bool_opt(
            options, 'func_name_highlighting', True)
        self.disabled_modules = get_list_opt(options, 'disabled_modules', [])

        self._functions = set()
        if self.func_name_highlighting:
            from pygments.lexers._lua_builtins import MODULES
            for mod, func in MODULES.iteritems():
                if mod not in self.disabled_modules:
                    self._functions.update(func)
        RegexLexer.__init__(self, **options)
Ejemplo n.º 48
0
    def __init__(self, **options):
        self.func_name_highlighting = get_bool_opt(
            options, 'func_name_highlighting', True)
        self.disabled_modules = get_list_opt(options, 'disabled_modules', [])

        self._functions = set()
        if self.func_name_highlighting:
            from pygments.lexers._lua_builtins import MODULES
            for mod, func in MODULES.iteritems():
                if mod not in self.disabled_modules:
                    self._functions.update(func)
        RegexLexer.__init__(self, **options)
Ejemplo n.º 49
0
 def __init__(self, **options):
     self.reserved_words = set()
     self.pervasives = set()
     # ISO Modula-2
     if get_bool_opt(options, 'iso', False):
         self.reserved_words.update(self.iso_reserved_words)
         self.pervasives.update(self.iso_pervasives)
     # Objective Modula-2
     elif get_bool_opt(options, 'objm2', False):
         self.reserved_words.update(self.objm2_reserved_words)
         self.pervasives.update(self.objm2_pervasives)
     # PIM Modula-2 (DEFAULT)
     else:
         self.reserved_words.update(self.pim_reserved_words)
         self.pervasives.update(self.pim_pervasives)
     # GNU extensions
     if get_bool_opt(options, 'gm2ext', False):
         self.reserved_words.update(self.gnu_reserved_words)
         self.pervasives.update(self.gnu_pervasives)
     # initialise
     RegexLexer.__init__(self, **options)
Ejemplo n.º 50
0
    def __init__(self, **options):
        Formatter.__init__(self, **options)
        self.docclass = options.get('docclass', 'article')
        self.preamble = options.get('preamble', '')
        self.linenos = get_bool_opt(options, 'linenos', False)
        self.linenostart = abs(get_int_opt(options, 'linenostart', 1))
        self.linenostep = abs(get_int_opt(options, 'linenostep', 1))
        self.verboptions = options.get('verboptions', '')
        self.nobackground = get_bool_opt(options, 'nobackground', False)
        self.commandprefix = options.get('commandprefix', 'PY')
        self.texcomments = get_bool_opt(options, 'texcomments', False)
        self.mathescape = get_bool_opt(options, 'mathescape', False)
        self.escapeinside = options.get('escapeinside', '')
        if len(self.escapeinside) == 2:
            self.left = self.escapeinside[0]
            self.right = self.escapeinside[1]
        else:
            self.escapeinside = ''
        self.envname = options.get('envname', u'Verbatim')

        self._create_stylesheet()
Ejemplo n.º 51
0
 def __init__(self, **options):
     self.reserved_words = set()
     self.pervasives = set()
     # ISO Modula-2
     if get_bool_opt(options, 'iso', False):
         self.reserved_words.update(self.iso_reserved_words)
         self.pervasives.update(self.iso_pervasives)
     # Objective Modula-2
     elif get_bool_opt(options, 'objm2', False):
         self.reserved_words.update(self.objm2_reserved_words)
         self.pervasives.update(self.objm2_pervasives)
     # PIM Modula-2 (DEFAULT)
     else:
         self.reserved_words.update(self.pim_reserved_words)
         self.pervasives.update(self.pim_pervasives)
     # GNU extensions
     if get_bool_opt(options, 'gm2ext', False):
         self.reserved_words.update(self.gnu_reserved_words)
         self.pervasives.update(self.gnu_pervasives)
     # initialise
     RegexLexer.__init__(self, **options)
Ejemplo n.º 52
0
    def __init__(self, **options):
        Formatter.__init__(self, **options)
        self.docclass = options.get('docclass', 'article')
        self.preamble = options.get('preamble', '')
        self.linenos = get_bool_opt(options, 'linenos', False)
        self.linenostart = abs(get_int_opt(options, 'linenostart', 1))
        self.linenostep = abs(get_int_opt(options, 'linenostep', 1))
        self.verboptions = options.get('verboptions', '')
        self.nobackground = get_bool_opt(options, 'nobackground', False)
        self.commandprefix = options.get('commandprefix', 'PY')
        self.texcomments = get_bool_opt(options, 'texcomments', False)
        self.mathescape = get_bool_opt(options, 'mathescape', False)
        self.escapeinside = options.get('escapeinside', '')
        if len(self.escapeinside) == 2:
            self.left = self.escapeinside[0]
            self.right = self.escapeinside[1]
        else:
            self.escapeinside = ''
        self.envname = options.get('envname', u'Verbatim')

        self._create_stylesheet()
Ejemplo n.º 53
0
 def __init__(self, **options):
     Filter.__init__(self, **options)
     for name, default in {'spaces': u'·', 'tabs': u'»', 'newlines': u'¶'}.items():
         opt = options.get(name, False)
         if isinstance(opt, basestring) and len(opt) == 1:
             setattr(self, name, opt)
         else:
             setattr(self, name, (opt and default or ''))
     tabsize = get_int_opt(options, 'tabsize', 8)
     if self.tabs:
         self.tabs += ' '*(tabsize-1)
     if self.newlines:
         self.newlines += '\n'
     self.wstt = get_bool_opt(options, 'wstokentype', True)
Ejemplo n.º 54
0
 def __init__(self, **options):
     Filter.__init__(self, **options)
     for name, default in list({'spaces': '·', 'tabs': '»', 'newlines': '¶'}.items()):
         opt = options.get(name, False)
         if isinstance(opt, str) and len(opt) == 1:
             setattr(self, name, opt)
         else:
             setattr(self, name, (opt and default or ''))
     tabsize = get_int_opt(options, 'tabsize', 8)
     if self.tabs:
         self.tabs += ' '*(tabsize-1)
     if self.newlines:
         self.newlines += '\n'
     self.wstt = get_bool_opt(options, 'wstokentype', True)
Ejemplo n.º 55
0
    def __init__(self, **options):
        self.python3 = get_bool_opt(options, 'python3', False)
        if self.python3:
            self.aliases = ['ipython3tb']
        else:
            self.aliases = ['ipython2tb', 'ipythontb']

        if self.python3:
            IPyLexer = IPython3Lexer
        else:
            IPyLexer = IPythonLexer

        DelegatingLexer.__init__(self, IPyLexer, IPythonPartialTracebackLexer,
                                 **options)
Ejemplo n.º 56
0
 def __init__(self, **options):
     Filter.__init__(self, **options)
     for name, default in [('spaces', '·'), ('tabs', '»'),
                           ('newlines', '¶')]:
         opt = options.get(name, False)
         if isinstance(opt, str) and len(opt) == 1:
             setattr(self, name, opt)
         else:
             setattr(self, name, (opt and default or ''))
     tabsize = get_int_opt(options, 'tabsize', 8)
     if self.tabs:
         self.tabs += ' ' * (tabsize - 1)
     if self.newlines:
         self.newlines += '\n'
     self.wstt = get_bool_opt(options, 'wstokentype', True)
Ejemplo n.º 57
0
    def __init__(self, **options):
        Formatter.__init__(self, **options)
        self.docclass = options.get('docclass', 'article')
        self.preamble = options.get('preamble', '')
        self.linenos = get_bool_opt(options, 'linenos', False)
        self.linenostart = abs(get_int_opt(options, 'linenostart', 1))
        self.linenostep = abs(get_int_opt(options, 'linenostep', 1))
        self.verbenvironment = options.get('verbenvironment', 'Verbatim')
        self.saveverbatimname = options.get('saveverbatimname', '')
        self.verboptions = options.get('verboptions', '')
        self.nobackground = get_bool_opt(options, 'nobackground', False)
        self.commandprefix = options.get('commandprefix', 'PY')
        self.texcomments = get_bool_opt(options, 'texcomments', False)
        self.mathescape = get_bool_opt(options, 'mathescape', False)
        # New options added with cilkhilite pygments plugin
        self.inline = get_bool_opt(options, 'inline', False)
        self.hidebydefault = get_bool_opt(options, 'hidebydefault', False)
        self.reindent = get_bool_opt(options, 'reindent', False)

        self._create_stylesheet()
def to_snake_case(self, lexer, stream, options):
    convert_all_names = get_bool_opt(options, "convert_all_names", default=False)
    if convert_all_names:
        for ttype, value in stream:
            if ttype is Name.Function or ttype is Name:
                results = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", value)
                results = re.sub("([a-z0-9])([A-Z])", r"\1_\2", results)
                value = results.lower()
            yield ttype, value
    else:
        lookahead, tokens = itertools.tee(stream)
        next(lookahead)
        for current_token in tokens:
            current_type = current_token[0]
            current_value = current_token[1]
            next_token = next(lookahead, None)
            if next_token:
                next_type = next_token[0]
                next_value = next_token[1]
                if current_type is Name.Function or is_function_call_token(
                    current_type, next_type, next_value
                ):
                    current_value = name_to_snake_case(current_value)
            yield current_type, current_value
Ejemplo n.º 59
0
 def __init__(self, **options):
     self.handlecodeblocks = get_bool_opt(options, 'handlecodeblocks', True)
     RegexLexer.__init__(self, **options)