``.
- :param body: body contents of the list.
- :param ordered: whether this list is ordered or not.
- """
- tag = 'ul'
- if ordered:
- tag = 'ol'
- return '<%s>\n%s\n' % (tag, body, tag)
-
- def list_item(self, text):
- """Rendering list item snippet. Like ``- ``."""
- return '
- %s
\n' % text
-
- def paragraph(self, text):
- """Rendering paragraph tags. Like ````."""
- return '
%s
\n' % text.strip(' ')
-
- def table(self, header, body):
- """Rendering table element. Wrap header and body in it.
- :param header: header part of the table.
- :param body: body part of the table.
- """
- return (
- '\n'
- ) % (header, body)
-
- def table_row(self, content):
- """Rendering a table row. Like ````.
- :param content: content of current table row.
- """
- return '
\n%s
\n' % content
-
- def table_cell(self, content, **flags):
- """Rendering a table cell. Like ```` `` | ``.
- :param content: content of current table cell.
- :param header: whether this is header or not.
- :param align: align of current table cell.
- """
- if flags['header']:
- tag = 'th'
- else:
- tag = 'td'
- align = flags['align']
- if not align:
- return '<%s>%s\n' % (tag, content, tag)
- return '<%s style="text-align:%s">%s\n' % (
- tag, align, content, tag
- )
-
- def double_emphasis(self, text):
- """Rendering **strong** text.
- :param text: text content for emphasis.
- """
- return '%s' % text
-
- def emphasis(self, text):
- """Rendering *emphasis* text.
- :param text: text content for emphasis.
- """
- return '%s' % text
-
- def codespan(self, text):
- """Rendering inline `code` text.
- :param text: text content for inline code.
- """
- text = escape(text.rstrip(), smart_amp=False)
- return '%s' % text
-
- def linebreak(self):
- """Rendering line break like ``
``."""
- if self.options.get('use_xhtml'):
- return '
\n'
- return '
\n'
-
- def strikethrough(self, text):
- """Rendering ~~strikethrough~~ text.
- :param text: text content for strikethrough.
- """
- return '%s' % text
-
- def text(self, text):
- """Rendering unformatted text.
- :param text: text content.
- """
- if self.options.get('parse_block_html'):
- return text
- return escape(text)
-
- def escape(self, text):
- """Rendering escape sequence.
- :param text: text content.
- """
- return escape(text)
-
- def autolink(self, link, is_email=False):
- """Rendering a given link or email address.
- :param link: link content or email address.
- :param is_email: whether this is an email or not.
- """
- text = link = escape_link(link)
- if is_email:
- link = 'mailto:%s' % link
- return '%s' % (link, text)
-
- def link(self, link, title, text):
- """Rendering a given link with content and title.
- :param link: href link for ```` tag.
- :param title: title content for `title` attribute.
- :param text: text content for description.
- """
- link = escape_link(link)
- if not title:
- return '%s' % (link, text)
- title = escape(title, quote=True)
- return '%s' % (link, title, text)
-
- def image(self, src, title, text):
- """Rendering a image with title and text.
- :param src: source link of the image.
- :param title: title text of the image.
- :param text: alt text of the image.
- """
- src = escape_link(src)
- text = escape(text, quote=True)
- if title:
- title = escape(title, quote=True)
- html = ' ' % html
- return '%s>' % html
-
- def inline_html(self, html):
- """Rendering span level pure html content.
- :param html: text content of the html snippet.
- """
- if self.options.get('escape'):
- return escape(html)
- return html
-
- def newline(self):
- """Rendering newline element."""
- return ''
-
- def footnote_ref(self, key, index):
- """Rendering the ref anchor of a footnote.
- :param key: identity key for the footnote.
- :param index: the index count of current footnote.
- """
- html = (
- ''
- ) % (escape(key), escape(key), index)
- return html
-
- def footnote_item(self, key, text):
- """Rendering a footnote item.
- :param key: identity key for the footnote.
- :param text: text content of the footnote.
- """
- back = (
- ''
- ) % escape(key)
- text = text.rstrip()
- if text.endswith(''):
- text = re.sub(r'<\/p>$', r'%s' % back, text)
- else:
- text = '%s%s ' % (text, back)
- html = '- %s
\n' % (escape(key), text)
- return html
-
- def footnotes(self, text):
- """Wrapper for all footnotes.
- :param text: contents of all footnotes.
- """
- html = '\n'
- return html % (self.hrule(), text)
-
-
-class Markdown(object):
- """The Markdown parser.
- :param renderer: An instance of ``Renderer``.
- :param inline: An inline lexer class or instance.
- :param block: A block lexer class or instance.
- """
- def __init__(self, renderer=None, inline=None, block=None, **kwargs):
- if not renderer:
- renderer = Renderer(**kwargs)
- else:
- kwargs.update(renderer.options)
-
- self.renderer = renderer
-
- if inline and inspect.isclass(inline):
- inline = inline(renderer, **kwargs)
- if block and inspect.isclass(block):
- block = block(**kwargs)
-
- if inline:
- self.inline = inline
- else:
- self.inline = InlineLexer(renderer, **kwargs)
-
- self.block = block or BlockLexer(BlockGrammar())
- self.footnotes = []
- self.tokens = []
-
- # detect if it should parse text in block html
- self._parse_block_html = kwargs.get('parse_block_html')
-
- def __call__(self, text):
- return self.parse(text)
-
- def render(self, text):
- """Render the Markdown text.
- :param text: markdown formatted text content.
- """
- return self.parse(text)
-
- def parse(self, text):
- out = self.output(preprocessing(text))
-
- keys = self.block.def_footnotes
-
- # reset block
- self.block.def_links = {}
- self.block.def_footnotes = {}
-
- # reset inline
- self.inline.links = {}
- self.inline.footnotes = {}
-
- if not self.footnotes:
- return out
-
- footnotes = filter(lambda o: keys.get(o['key']), self.footnotes)
- self.footnotes = sorted(
- footnotes, key=lambda o: keys.get(o['key']), reverse=True
- )
-
- body = self.renderer.placeholder()
- while self.footnotes:
- note = self.footnotes.pop()
- body += self.renderer.footnote_item(
- note['key'], note['text']
- )
-
- out += self.renderer.footnotes(body)
- return out
-
- def pop(self):
- if not self.tokens:
- return None
- self.token = self.tokens.pop()
- return self.token
-
- def peek(self):
- if self.tokens:
- return self.tokens[-1]
- return None # pragma: no cover
-
- def output(self, text, rules=None):
- self.tokens = self.block(text, rules)
- self.tokens.reverse()
-
- self.inline.setup(self.block.def_links, self.block.def_footnotes)
-
- out = self.renderer.placeholder()
- while self.pop():
- out += self.tok()
- return out
-
- def tok(self):
- t = self.token['type']
-
- # sepcial cases
- if t.endswith('_start'):
- t = t[:-6]
-
- return getattr(self, 'output_%s' % t)()
-
- def tok_text(self):
- text = self.token['text']
- while self.peek()['type'] == 'text':
- text += '\n' + self.pop()['text']
- return self.inline(text)
-
- def output_newline(self):
- return self.renderer.newline()
-
- def output_hrule(self):
- return self.renderer.hrule()
-
- def output_heading(self):
- return self.renderer.header(
- self.inline(self.token['text']),
- self.token['level'],
- self.token['text'],
- )
-
- def output_code(self):
- return self.renderer.block_code(
- self.token['text'], self.token['lang']
- )
-
- def output_table(self):
- aligns = self.token['align']
- aligns_length = len(aligns)
- cell = self.renderer.placeholder()
-
- # header part
- header = self.renderer.placeholder()
- for i, value in enumerate(self.token['header']):
- align = aligns[i] if i < aligns_length else None
- flags = {'header': True, 'align': align}
- cell += self.renderer.table_cell(self.inline(value), **flags)
-
- header += self.renderer.table_row(cell)
-
- # body part
- body = self.renderer.placeholder()
- for i, row in enumerate(self.token['cells']):
- cell = self.renderer.placeholder()
- for j, value in enumerate(row):
- align = aligns[j] if j < aligns_length else None
- flags = {'header': False, 'align': align}
- cell += self.renderer.table_cell(self.inline(value), **flags)
- body += self.renderer.table_row(cell)
-
- return self.renderer.table(header, body)
-
- def output_block_quote(self):
- body = self.renderer.placeholder()
- while self.pop()['type'] != 'block_quote_end':
- body += self.tok()
- return self.renderer.block_quote(body)
-
- def output_list(self):
- ordered = self.token['ordered']
- body = self.renderer.placeholder()
- while self.pop()['type'] != 'list_end':
- body += self.tok()
- return self.renderer.list(body, ordered)
-
- def output_list_item(self):
- body = self.renderer.placeholder()
- while self.pop()['type'] != 'list_item_end':
- if self.token['type'] == 'text':
- body += self.tok_text()
- else:
- body += self.tok()
-
- return self.renderer.list_item(body)
-
- def output_loose_item(self):
- body = self.renderer.placeholder()
- while self.pop()['type'] != 'list_item_end':
- body += self.tok()
- return self.renderer.list_item(body)
-
- def output_footnote(self):
- self.inline._in_footnote = True
- body = self.renderer.placeholder()
- key = self.token['key']
- while self.pop()['type'] != 'footnote_end':
- body += self.tok()
- self.footnotes.append({'key': key, 'text': body})
- self.inline._in_footnote = False
- return self.renderer.placeholder()
-
- def output_close_html(self):
- text = self.token['text']
- return self.renderer.block_html(text)
-
- def output_open_html(self):
- text = self.token['text']
- tag = self.token['tag']
- if self._parse_block_html and tag not in _pre_tags:
- text = self.inline(text, rules=self.inline.inline_html_rules)
- extra = self.token.get('extra') or ''
- html = '<%s%s>%s' % (tag, extra, text, tag)
- return self.renderer.block_html(html)
-
- def output_paragraph(self):
- return self.renderer.paragraph(self.inline(self.token['text']))
-
- def output_text(self):
- return self.renderer.paragraph(self.tok_text())
-
-
-def markdown(text, escape=True, **kwargs):
- """Render markdown formatted text to html.
- :param text: markdown formatted text content.
- :param escape: if set to False, all html tags will not be escaped.
- :param use_xhtml: output with xhtml tags.
- :param hard_wrap: if set to True, it will use the GFM line breaks feature.
- :param parse_block_html: parse text only in block level html.
- :param parse_inline_html: parse text only in inline level html.
- """
- return Markdown(escape=escape, **kwargs)(text)
\ No newline at end of file
|
