def setUp(self):
from marko import Markdown, HTMLRenderer
from marko.ext.pangu import PanguRendererMixin
class MyRenderer(PanguRendererMixin, HTMLRenderer):
pass
self.markdown = Markdown(renderer=MyRenderer)
def setUp(self):
from marko import HTMLRenderer, Markdown
from marko.ext.toc import TocRendererMixin
class MyRenderer(TocRendererMixin, HTMLRenderer):
pass
self.markdown = Markdown(renderer=MyRenderer)
def compile_markdown(markdown_source: str) -> MarkdownRecipe:
"""
Compile a recipe grid flavoured markdown document, producing a
:py:class:`MarkdownRecipe` which may be rescaled and rendered into the
final HTML form as required.
Internally calls :py:func:`recipe_grid.compiler.compile` and so may throw
the same kinds of exceptions when syntax errors in the recipe sources are
encountered.
"""
return cast(MarkdownRecipe, Markdown(extensions=[RecipeGrid])(markdown_source))
def setUp(self):
from marko import Parser, HTMLRenderer, Markdown
from marko.ext.footnote import FootnoteParserMixin, FootnoteRendererMixin
class MyParser(FootnoteParserMixin, Parser):
pass
class MyRenderer(FootnoteRendererMixin, HTMLRenderer):
pass
self.markdown = Markdown(MyParser, MyRenderer)
def test_gemini_renderer_links() -> None:
"""
Test rendering links.
"""
gemini = Markdown(renderer=GeminiRenderer)
assert (gemini.convert(
"""
This is a paragraph with [a link](https://example.com/). It is a good paragraph.
This one [also has a link](https://example.net/). It also has some *emphasis* and **bold**.
And this one is a special paragraph because it has not just [one](https://example.com/one),
but [two](https://example.com/two) links. That is quite a lot.
This other paragraph also has [a link][ref], using a reference. It's very fancy.
[ref]: https://example.org/foo "This is foo"
This one has an auto link <https://example.com/autolink>.
That is it.
""", ) == """
This is a paragraph with a link. It is a good paragraph.
=> https://example.com/ a link
This one also has a link. It also has some emphasis and bold.
=> https://example.net/ also has a link
And this one is a special paragraph because it has not just one,
but two links. That is quite a lot.
=> https://example.com/one one
=> https://example.com/two two
This other paragraph also has a link, using a reference. It's very fancy.
=> https://example.org/foo This is foo
This one has an auto link https://example.com/autolink.
=> https://example.com/autolink https://example.com/autolink
That is it.
""")
def test_gemini_renderer_link_ref_def() -> None:
"""
Test rendering a link definition reference.
"""
gemini = Markdown(renderer=GeminiRenderer)
assert (gemini.convert(
"""
Hi, here's my [thing that I just casually mention][tt] sometimes.
[tt]: gemini://my.boring/url "I like this link"
""", ) == """
Hi, here's my thing that I just casually mention sometimes.
=> gemini://my.boring/url I like this link
""")
def test_gemini_renderer() -> None:
"""
Test ``GeminiRenderer``.
"""
double_space = " "
gemini = Markdown(renderer=GeminiRenderer)
assert (gemini.convert(
f"""
# Header 1
## Header 2
### Header 3
#### Header 4
- Mercury
- Gemini
- Apollo
> This is{double_space}
> A multiline{double_space}
> blockquote{double_space}
*This* is a **paragraph**. With `code`.
This is an [inline link](https://example.com/). This is [another](https://example.org/).
```
This is some code.
```
End.
""", ) == f"""
# Header 1
## Header 2
### Header 3
### Header 4
* Mercury
* Gemini
* Apollo
> This is
> A multiline
> blockquote{double_space}
This is a paragraph. With code.
This is an inline link. This is another.
=> https://example.com/ inline link
=> https://example.org/ another
```
This is some code.
```
End.
""")
align = ' align="{}"'.format(element.align)
return "<{tag}{align}>{children}</{tag}>\n".format(
tag=tag, children=self.render_children(element), align=align
)
def render_url(self, element):
return self.render_link(element)
class GFM(object):
elements = [
elements.Paragraph,
elements.ListItem,
elements.Strikethrough,
elements.Url,
elements.Table,
elements.TableRow,
elements.TableCell,
]
renderer_mixins = [GFMRendererMixin]
GFMExtension = helpers._Deprecated(GFM)
gfm = Markdown()
gfm.use(GFM)
def make_extension():
return GFM()
""" Markdown class """ from marko import Markdown from .extensions import FlogParser, FlogRenderer markdown = Markdown(FlogParser, FlogRenderer)
def render_plain_text(self, element):
if isinstance(element.children, str):
return aguideEscape(element.children)
return self.render_children(element)
def render_raw_text(self, element):
return aguideEscape(element.children)
class AmigaGuide:
elements = [HeadingTOC, ExternalLinkRef, Document, TableOfContents]
renderer_mixins = [AmigaGuideMixin]
markdown = Markdown(extensions=[AmigaGuide])
if len(sys.argv) != 2:
print("usage: %s <foo.md>" % sys.argv[0])
sys.exit(1)
infn = sys.argv[1]
with open(infn, "r") as mdf:
md = mdf.read()
aguide = markdown.convert(md)
#with open (OUTPUT_FN, "w", encoding="latin1") as outf:
# outf.write(aguide)
def render_paragraph(self, element):
children = self.render_children(element)
return """<TextBlock Text="{}"/>\n""".format(children)
def render_raw_text(self, element):
return self.xml_escape(element.children)
def render_line_break(self, element):
return " "
def render_literal(self, element):
return self.xml_escape(element.children)
@staticmethod
def xml_escape(str):
return _xml_escape(str, entities={"'": "'", "\"": """})
if __name__ == "__main__":
__location__ = os.path.realpath(
os.path.join(os.getcwd(), os.path.dirname(__file__)))
# Load help markdown
with open(os.path.join(__location__, "help.md"), "r",
encoding="utf8") as f:
text = f.read()
markdown = Markdown(renderer=XamlRenderer)
print(markdown(text))
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from __future__ import print_function
import re
import sys
import codecs
import json
from marko import Markdown
from marko.ext.gfm import GFMarkdown
from traceback import print_tb
from argparse import ArgumentParser
from .normalize import normalize_html
SPECS = {
'commonmark': ('tests/spec/commonmark.json', Markdown()),
'gfm': ('tests/spec/gfm.json', GFMarkdown())
}
def run_tests(test_entries,
markdown,
start=None,
end=None,
quiet=False,
verbose=False):
start = start or 0
end = end or sys.maxsize
results = [
run_test(test_entry, markdown, quiet) for test_entry in test_entries
if test_entry['example'] >= start and test_entry['example'] <= end
]
