eric: comparison eric6/ThirdParty/Pygments/pygments/lexers/markup.py

-:a3cf077a8db3
+:25f42e208e08
 pygments.lexers.markup
 ~~~~~~~~~~~~~~~~~~~~~~
 Lexers for non-HTML markup languages.
-:copyright: Copyright 2006-2019 by the Pygments team, see AUTHORS.
+:copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
 :license: BSD, see LICENSE for details.
 """
 import re
 from pygments.util import get_bool_opt, ClassNotFound
 __all__ = ['BBCodeLexer', 'MoinWikiLexer', 'RstLexer', 'TexLexer', 'GroffLexer',
 'MozPreprocHashLexer', 'MozPreprocPercentLexer',
 'MozPreprocXulLexer', 'MozPreprocJavascriptLexer',
-'MozPreprocCssLexer', 'MarkdownLexer']
+'MozPreprocCssLexer', 'MarkdownLexer', 'TiddlyWiki5Lexer']
 class BBCodeLexer(RegexLexer):
 """
 A lexer that highlights BBCode(-like) syntax.
 if len(line) > indention_size:
 ins.append((len(code), [(0, Text, line[:indention_size])]))
 code += line[indention_size:]
 else:
 code += line
-for item in do_insertions(ins, lexer.get_tokens_unprocessed(code)):
+yield from do_insertions(ins, lexer.get_tokens_unprocessed(code))
-yield item
 # from docutils.parsers.rst.states
-closers = u'\'")]}>\u2019\u201d\xbb!?'
+closers = '\'")]}>\u2019\u201d\xbb!?'
-unicode_delimiters = u'\u2010\u2011\u2012\u2013\u2014\u00a0'
+unicode_delimiters = '\u2010\u2011\u2012\u2013\u2014\u00a0'
 end_string_suffix = (r'((?=$)|(?=[-/:.,; \n\x00%s%s]))'
 % (re.escape(unicode_delimiters),
 re.escape(closers)))
 tokens = {
 # Line blocks
 (r'^(\s*)(\|)( .+\n(?:\|  .+\n)*)',
 bygroups(Text, Operator, using(this, state='inline'))),
 # Sourcecode directives
 (r'^( *\.\.)(\s*)((?:source)?code(?:-block)?)(::)([ \t]*)([^\n]+)'
-r'(\n[ \t]*\n)([ \t]+)(.*)(\n)((?:(?:\8.*|)\n)+)',
+r'(\n[ \t]*\n)([ \t]+)(.*)(\n)((?:(?:\8.*)?\n)+)',
 _handle_sourcecode),
 # A directive
 (r'^( *\.\.)(\s*)([\w:-]+?)(::)(?:([ \t]*)(.*))',
 bygroups(Punctuation, Text, Operator.Word, Punctuation, Text,
 using(this, state='inline'))),
 bygroups(Text, Name.Class, Text)),
 # Definition list
 (r'^(\S.*(?<!::)\n)((?:(?: +.*)\n)+)',
 bygroups(using(this, state='inline'), using(this, state='inline'))),
 # Code blocks
-(r'(::)(\n[ \t]*\n)([ \t]+)(.*)(\n)((?:(?:\3.*|)\n)+)',
+(r'(::)(\n[ \t]*\n)([ \t]+)(.*)(\n)((?:(?:\3.*)?\n)+)',
 bygroups(String.Escape, Text, String, String, Text, String)),
 include('inline'),
 ],
 'inline': [
 (r'\\.', Text),  # escape
 aliases = ['xul+mozpreproc']
 filenames = ['*.xul.in']
 mimetypes = []
 def __init__(self, **options):
-super(MozPreprocXulLexer, self).__init__(
+super().__init__(XmlLexer, MozPreprocHashLexer, **options)
-XmlLexer, MozPreprocHashLexer, **options)
 class MozPreprocJavascriptLexer(DelegatingLexer):
 """
 Subclass of the `MozPreprocHashLexer` that highlights unlexed data with the
 aliases = ['javascript+mozpreproc']
 filenames = ['*.js.in']
 mimetypes = []
 def __init__(self, **options):
-super(MozPreprocJavascriptLexer, self).__init__(
+super().__init__(JavascriptLexer, MozPreprocHashLexer, **options)
-JavascriptLexer, MozPreprocHashLexer, **options)
 class MozPreprocCssLexer(DelegatingLexer):
 """
 Subclass of the `MozPreprocHashLexer` that highlights unlexed data with the
 aliases = ['css+mozpreproc']
 filenames = ['*.css.in']
 mimetypes = []
 def __init__(self, **options):
-super(MozPreprocCssLexer, self).__init__(
+super().__init__(CssLexer, MozPreprocPercentLexer, **options)
-CssLexer, MozPreprocPercentLexer, **options)
 class MarkdownLexer(RegexLexer):
 """
 For `Markdown <https://help.github.com/categories/writing-on-github/>`_ markup.
 .. versionadded:: 2.2
 """
 name = 'markdown'
 aliases = ['md']
-filenames = ['*.md']
+filenames = ['*.md', '*.markdown']
 mimetypes = ["text/x-markdown"]
 flags = re.MULTILINE
 def _handle_codeblock(self, match):
 """
 match args: 1:backticks, 2:lang_name, 3:newline, 4:code, 5:backticks
 """
 from pygments.lexers import get_lexer_by_name
 # section header
-yield match.start(1), String        , match.group(1)
+yield match.start(1), String.Backtick, match.group(1)
-yield match.start(2), String        , match.group(2)
+yield match.start(2), String.Backtick, match.group(2)
-yield match.start(3), Text          , match.group(3)
+yield match.start(3), Text           , match.group(3)
 # lookup lexer if wanted and existing
 lexer = None
 if self.handlecodeblocks:
 try:
 # no lexer for this language. handle it like it was a code block
 if lexer is None:
 yield match.start(4), String, code
 else:
-for item in do_insertions([], lexer.get_tokens_unprocessed(code)):
+yield from do_insertions([], lexer.get_tokens_unprocessed(code))
-yield item
+yield match.start(5), String.Backtick, match.group(5)
-yield match.start(5), String        , match.group(5)
+tokens = {
-tokens = {
+'root': [
-'root': [
+# heading with '#' prefix (atx-style)
-# heading with pound prefix
+(r'(^#[^#].+)(\n)', bygroups(Generic.Heading, Text)),
-(r'^(#)([^#].+\n)', bygroups(Generic.Heading, Text)),
+# subheading with '#' prefix (atx-style)
-(r'^(#{2,6})(.+\n)', bygroups(Generic.Subheading, Text)),
+(r'(^#{2,6}[^#].+)(\n)', bygroups(Generic.Subheading, Text)),
+# heading with '=' underlines (Setext-style)
+(r'^(.+)(\n)(=+)(\n)', bygroups(Generic.Heading, Text, Generic.Heading, Text)),
+# subheading with '-' underlines (Setext-style)
+(r'^(.+)(\n)(-+)(\n)', bygroups(Generic.Subheading, Text, Generic.Subheading, Text)),
 # task list
 (r'^(\s*)([*-] )(\[[ xX]\])( .+\n)',
 bygroups(Text, Keyword, Keyword, using(this, state='inline'))),
-# bulleted lists
+# bulleted list
 (r'^(\s*)([*-])(\s)(.+\n)',
 bygroups(Text, Keyword, Text, using(this, state='inline'))),
-# numbered lists
+# numbered list
 (r'^(\s*)([0-9]+\.)( .+\n)',
 bygroups(Text, Keyword, using(this, state='inline'))),
 # quote
 (r'^(\s*>\s)(.+\n)', bygroups(Keyword, Generic.Emph)),
+# code block fenced by 3 backticks
+(r'^(\s*```\n(.+\n)+\s*```$)', String.Backtick),
+# code block with language
+(r'^(\s*```)(\w+)(\n)([\w\W]*?)(^\s*```$)', _handle_codeblock),
+# code block indented with 4 spaces or 1 tab
+(r'(\n\n)((\ {4}|\t)(.+\n)+)', bygroups(Text, String.Backtick)),
+include('inline'),
+],
+'inline': [
+# escape
+(r'\\.', Text),
+# inline code
+(r'([^`])(`[^`\n]+`)', bygroups(Text, String.Backtick)),
+# warning: the following rules eat outer tags.
+# eg. **foo _bar_ baz** => foo and baz are not recognized as bold
+# bold fenced by '**'
+(r'(\*\*[^* \n][^*\n]*\*\*)', bygroups(Generic.Strong)),
+# # bold fenced by '__'
+(r'(\_\_[^_ \n][^_\n]*\_\_)', bygroups(Generic.Strong)),
+# italics fenced by '*'
+(r'(\*[^* \n][^*\n]*\*)', bygroups(Generic.Emph)),
+# italics fenced by '_'
+(r'(\_[^_ \n][^_\n]*\_)', bygroups(Generic.Emph)),
+# strikethrough
+(r'([^~]*)(~~[^~]+~~)', bygroups(Text, Generic.Deleted)),
+# mentions and topics (twitter and github stuff)
+(r'[@#][\w/:]+', Name.Entity),
+# (image?) links eg: ![Image of Yaktocat](https://octodex.github.com/images/yaktocat.png)
+(r'(!?\[)([^]]+)(\])(\()([^)]+)(\))',
+bygroups(Text, Name.Tag, Text, Text, Name.Attribute, Text)),
+# reference-style links, e.g.:
+#   [an example][id]
+#   [id]: http://example.com/
+(r'(\[)([^]]+)(\])(\[)([^]]*)(\])',
+bygroups(Text, Name.Tag, Text, Text, Name.Label, Text)),
+(r'^(\s*\[)([^]]*)(\]:\s*)(.+)',
+bygroups(Text, Name.Label, Text, Name.Attribute)),
+# general text, must come last!
+(r'[^\\\s]+', Text),
+(r'.', Text),
+],
+}
+def __init__(self, **options):
+self.handlecodeblocks = get_bool_opt(options, 'handlecodeblocks', True)
+RegexLexer.__init__(self, **options)
+class TiddlyWiki5Lexer(RegexLexer):
+"""
+For `TiddlyWiki5 <https://tiddlywiki.com/#TiddlerFiles>`_ markup.
+.. versionadded:: 2.7
+"""
+name = 'tiddler'
+aliases = ['tid']
+filenames = ['*.tid']
+mimetypes = ["text/vnd.tiddlywiki"]
+flags = re.MULTILINE
+def _handle_codeblock(self, match):
+"""
+match args: 1:backticks, 2:lang_name, 3:newline, 4:code, 5:backticks
+"""
+from pygments.lexers import get_lexer_by_name
+# section header
+yield match.start(1), String, match.group(1)
+yield match.start(2), String, match.group(2)
+yield match.start(3), Text,   match.group(3)
+# lookup lexer if wanted and existing
+lexer = None
+if self.handlecodeblocks:
+try:
+lexer = get_lexer_by_name(match.group(2).strip())
+except ClassNotFound:
+pass
+code = match.group(4)
+# no lexer for this language. handle it like it was a code block
+if lexer is None:
+yield match.start(4), String, code
+return
+yield from do_insertions([], lexer.get_tokens_unprocessed(code))
+yield match.start(5), String, match.group(5)
+def _handle_cssblock(self, match):
+"""
+match args: 1:style tag 2:newline, 3:code, 4:closing style tag
+"""
+from pygments.lexers import get_lexer_by_name
+# section header
+yield match.start(1), String, match.group(1)
+yield match.start(2), String, match.group(2)
+lexer = None
+if self.handlecodeblocks:
+try:
+lexer = get_lexer_by_name('css')
+except ClassNotFound:
+pass
+code = match.group(3)
+# no lexer for this language. handle it like it was a code block
+if lexer is None:
+yield match.start(3), String, code
+return
+yield from do_insertions([], lexer.get_tokens_unprocessed(code))
+yield match.start(4), String, match.group(4)
+tokens = {
+'root': [
+# title in metadata section
+(r'^(title)(:\s)(.+\n)', bygroups(Keyword, Text, Generic.Heading)),
+# headings
+(r'^(!)([^!].+\n)', bygroups(Generic.Heading, Text)),
+(r'^(!{2,6})(.+\n)', bygroups(Generic.Subheading, Text)),
+# bulleted or numbered lists or single-line block quotes
+# (can be mixed)
+(r'^(\s*)([*#>]+)(\s*)(.+\n)',
+bygroups(Text, Keyword, Text, using(this, state='inline'))),
+# multi-line block quotes
+(r'^(<<<.*\n)([\w\W]*?)(^<<<.*$)', bygroups(String, Text, String)),
+# table header
+(r'^(\|.*?\|h)$', bygroups(Generic.Strong)),
+# table footer or caption
+(r'^(\|.*?\|[cf])$', bygroups(Generic.Emph)),
+# table class
+(r'^(\|.*?\|k)$', bygroups(Name.Tag)),
+# definitions
+(r'^(;.*)$', bygroups(Generic.Strong)),
 # text block
 (r'^(```\n)([\w\W]*?)(^```$)', bygroups(String, Text, String)),
 # code block with language
 (r'^(```)(\w+)(\n)([\w\W]*?)(^```$)', _handle_codeblock),
+# CSS style block
+(r'^(<style>)(\n)([\w\W]*?)(^</style>$)', _handle_cssblock),
+include('keywords'),
 include('inline'),
+],
+'keywords': [
+(words((
+'\\define', '\\end', 'caption', 'created', 'modified', 'tags',
+'title', 'type'), prefix=r'^', suffix=r'\b'),
+Keyword),
 ],
 'inline': [
 # escape
 (r'\\.', Text),
+# created or modified date
+(r'\d{17}', Number.Integer),
 # italics
-(r'(\s)([*_][^*_]+[*_])(\W|\n)', bygroups(Text, Generic.Emph, Text)),
+(r'(\s)(//[^/]+//)((?=\W|\n))',
+bygroups(Text, Generic.Emph, Text)),
+# superscript
+(r'(\s)(\^\^[^\^]+\^\^)', bygroups(Text, Generic.Emph)),
+# subscript
+(r'(\s)(,,[^,]+,,)', bygroups(Text, Generic.Emph)),
+# underscore
+(r'(\s)(__[^_]+__)', bygroups(Text, Generic.Strong)),
 # bold
-# warning: the following rule eats internal tags. eg. **foo _bar_ baz** bar is not italics
+(r"(\s)(''[^']+'')((?=\W|\n))",
-(r'(\s)((\*\*|__).*\3)((?=\W|\n))', bygroups(Text, Generic.Strong, None, Text)),
+bygroups(Text, Generic.Strong, Text)),
-# "proper way" (r'(\s)([*_]{2}[^*_]+[*_]{2})((?=\W|\n))', bygroups(Text, Generic.Strong, Text)),
 # strikethrough
-(r'(\s)(~~[^~]+~~)((?=\W|\n))', bygroups(Text, Generic.Deleted, Text)),
+(r'(\s)(~~[^~]+~~)((?=\W|\n))',
+bygroups(Text, Generic.Deleted, Text)),
+# TiddlyWiki variables
+(r'<<[^>]+>>', Name.Tag),
+(r'\$\$[^$]+\$\$', Name.Tag),
+(r'\$\([^)]+\)\$', Name.Tag),
+# TiddlyWiki style or class
+(r'^@@.*$', Name.Tag),
+# HTML tags
+(r'</?[^>]+>', Name.Tag),
 # inline code
 (r'`[^`]+`', String.Backtick),
-# mentions and topics (twitter and github stuff)
+# HTML escaped symbols
-(r'[@#][\w/:]+', Name.Entity),
+(r'&\S*?;', String.Regex),
-# (image?) links eg: ![Image of Yaktocat](https://octodex.github.com/images/yaktocat.png)
+# Wiki links
-(r'(!?\[)([^]]+)(\])(\()([^)]+)(\))', bygroups(Text, Name.Tag, Text, Text, Name.Attribute, Text)),
+(r'(\[{2})([^]\|]+)(\]{2})', bygroups(Text, Name.Tag, Text)),
-# reference-style links, e.g.:
+# External links
-#   [an example][id]
+(r'(\[{2})([^]\|]+)(\|)([^]\|]+)(\]{2})',
-#   [id]: http://example.com/
+bygroups(Text, Name.Tag, Text, Name.Attribute, Text)),
-(r'(\[)([^]]+)(\])(\[)([^]]*)(\])', bygroups(Text, Name.Tag, Text, Text, Name.Label, Text)),
+# Transclusion
-(r'^(\s*\[)([^]]*)(\]:\s*)(.+)', bygroups(Text, Name.Label, Text, Name.Attribute)),
+(r'(\{{2})([^}]+)(\}{2})', bygroups(Text, Name.Tag, Text)),
+# URLs
+(r'(\b.?.?tps?://[^\s"]+)', bygroups(Name.Attribute)),
 # general text, must come last!
-(r'[^\\\s]+', Text),
+(r'[\w]+', Text),
-(r'.', Text),
+(r'.', Text)
 ],
 }
 def __init__(self, **options):
 self.handlecodeblocks = get_bool_opt(options, 'handlecodeblocks', True)

Mercurial Repositories > eric / file comparison

comparison: eric6/ThirdParty/Pygments/pygments/lexers/markup.py

eric6/ThirdParty/Pygments/pygments/lexers/markup.py