def test_checklists():
source = """
* [ ] foo
* [x] bar
* [ ] baz
""".strip()
expected = """
<ul class="check-list">
<li><input type="checkbox" disabled> foo</li>
<li><input type="checkbox" disabled checked> bar</li>
<li><input type="checkbox" disabled> baz</li>
</ul>
""".strip()
html = markdown(source,
extensions=[ChecklistExtension(list_class="check-list")])
assert html == expected
expected = """
<ul class="checklist">
<li><label><input type="checkbox" disabled> foo</label></li>
<li><label><input type="checkbox" disabled checked> bar</label></li>
<li><label><input type="checkbox" disabled> baz</label></li>
</ul>
""".strip()
html = markdown(source,
extensions=[ChecklistExtension(render_item=render_item)])
assert html == expected
def __init__(self):
"""
Attributes
----------
regex_codeblock : re.compile object
regex_codeinline : re.compile object
regex_overtheme : re.compile object
mkd : markdown.Markdown object
markdown converter
"""
self.regex_codeblock = __regex_codeblock__
self.regex_codeinline = __regex_codeinline__
self.regex_overtheme = __regex_overtheme__
if __mdx_checklist__:
self.mkd = markdown.Markdown(output_format='html5',
extensions=['smarty',
'extra',
ChecklistExtension(),
MathJaxExtension()])
else:
self.mkd = markdown.Markdown(output_format='html5',
extensions=['smarty',
'extra',
MathJaxExtension()])
return
def __init__(self, settings: MarkdownSettings):
self.settings = settings
self.extensions = []
if self.settings.enable_checklist:
self.extensions.append(ChecklistExtension())
if self.settings.enable_codehilite:
self.extensions.append(
CodeHiliteExtension(**self.settings.codehilite_options)
)
if self.settings.enable_fenced_code:
self.extensions.append(FencedCodeExtension())
if self.settings.enable_footnotes:
self.extensions.append(FootnoteExtension(**self.settings.footnotes_options))
if self.settings.enable_smartypants:
self.extensions.append(SmartyExtension(**self.settings.smartypants_options))
if self.settings.enable_toc:
self.extensions.append(TocExtension(**self.settings.toc_options))
if self.settings.enable_truly_sane_lists:
self.extensions.append(
TrulySaneListExtension(**self.settings.truly_sane_lists_options)
)
super().__init__(
output_format=self.settings.output_format,
tab_length=self.settings.tab_length,
extensions=self.extensions,
)
def test_class():
source = """
* [x] foo
* [ ] bar
* [X] baz
----
* [ ] lorem
* [x] ipsum
* [ ] ...
""".strip()
html = markdown(source, extensions=[ChecklistExtension()])
assert html == """
<ul class="checklist">
<li><input type="checkbox" disabled="disabled" checked="checked" /> foo</li>
<li><input type="checkbox" disabled="disabled" /> bar</li>
<li><input type="checkbox" disabled="disabled" checked="checked" /> baz</li>
</ul>
<hr />
<ul class="checklist">
<li><input type="checkbox" disabled="disabled" /> lorem</li>
<li><input type="checkbox" disabled="disabled" checked="checked" /> ipsum</li>
<li><input type="checkbox" disabled="disabled" /> ...</li>
</ul>
""".strip()
def __init__(self, sitedir, project):
self.sitedir = sitedir
self.filelist = project.filelist
self.navlist = project.navlist
self.taglist = project.taglist
self.site = project.site
tableclass = md_extensions.TableClassExtension()
projectref = md_extensions.ProjectReferenceExtension()
checklist = ChecklistExtension()
extensions = [
'extra', 'codehilite', 'headerid', 'toc', 'smarty', tableclass,
projectref, checklist
]
extension_configs = {
'codehilite': [('guess_lang', 'False'), ('linenums', 'False')],
'headerid': [('level', 2)]
}
self.md = markdown.Markdown(extensions=extensions,
extension_configs=extension_configs)
self.md.site = self.site
env = self.env = jinja2.Environment(
loader=jinja2.FileSystemLoader(layoutdir),
lstrip_blocks=True,
trim_blocks=True)
env.filters.update(project.filters)
self.templates = {}
for layout in project.layouts:
self.templates[layout] = self.env.get_template(layout + '.html')
# layout for tags is optional, triggers index file generation per tag
try:
self.templates[tag_layout] = self.env.get_template(tag_layout +
'.html')
except jinja2.exceptions.TemplateNotFound:
if self.taglist:
warn(tag_layout_warning, UrubuWarning)
def markdown2html(source, no_p=False):
"""Convert markdown source to html.
Parameters
----------
source : str
string (as single stream) containing the source
no_p : bool, optional
if True the converted contents is not inserted into the <p></p> tags
Returns
-------
str
converted source
"""
if __mdx_checklist__:
mkd = markdown.Markdown(output_format='html5',
extensions=[
'smarty', 'extra',
CustomSpanClassExtension(),
ChecklistExtension(),
MathJaxExtension()
])
else:
mkd = markdown.Markdown(
output_format='html5',
extensions=['smarty', 'extra',
MathJaxExtension()])
markup = mkd.reset().convert(source)
if no_p:
p_start = '<p>'
p_end = '</p>'
if markup.startswith(p_start) and markup.endswith(p_end):
markup = markup[len(p_start):-len(p_end)]
return markup
def __init__(self, baseDir):
assert os.path.exists(baseDir), "{} does not exist".format(baseDir)
assert os.path.isdir(baseDir), "{} is not a folder".format(baseDir)
self.baseDir = os.path.abspath(baseDir)
self.fs_path = partial(get_fs_path, self.baseDir)
self.res_path = partial(get_resource_path, self.baseDir)
self.default_template_string = """<html><body>{{ __body__ }}</body></html>"""
self.md = markdown.Markdown(extensions=[
"meta", # Built-in extensions
"tables",
"fenced_code",
"def_list",
"abbr",
"sane_lists",
HighlightExtension(), # extensions from pip
ChecklistExtension()
])
def test_syntax_variations():
source = """
Hello World
===========
- [x] foo
- [ ] bar
- [X] baz
lorem ipsum
""".strip()
html = markdown(source, extensions=[ChecklistExtension()])
assert html == """
<h1>Hello World</h1>
<ul class="checklist">
<li><input type="checkbox" disabled="disabled" checked="checked" /> foo</li>
<li><input type="checkbox" disabled="disabled" /> bar</li>
<li><input type="checkbox" disabled="disabled" checked="checked" /> baz</li>
</ul>
<p>lorem ipsum</p>
""".strip()
def test_checklists():
source = """
Hello World
===========
* [ ] foo
* [x] bar
* [ ] baz
lorem ipsum
""".strip()
html = markdown(source)
assert html == """
<h1>Hello World</h1>
<ul>
<li>[ ] foo</li>
<li>[x] bar</li>
<li>[ ] baz</li>
</ul>
<p>lorem ipsum</p>
""".strip()
expected = """
<h1>Hello World</h1>
<ul class="checklist">
<li><input type="checkbox" disabled="disabled" /> foo</li>
<li><input type="checkbox" disabled="disabled" checked="checked" /> bar</li>
<li><input type="checkbox" disabled="disabled" /> baz</li>
</ul>
<p>lorem ipsum</p>
""".strip()
html = markdown(source, extensions=[ChecklistExtension()])
assert html == expected
html = markdown(source, extensions=['markdown_checklist.extension'])
assert html == expected
def _get_md_obj() -> Markdown:
exts: list = ['extra',
'meta',
'sane_lists',
'smarty',
'toc',
'wikilinks',
# stripTitle generates an error when True,
# if there is no title attr
YafgExtension(stripTitle=False,
figureClass="",
figcaptionClass="",
figureNumbering=False,
figureNumberClass="number",
figureNumberText="Figure"),
HighlightExtension(),
ChecklistExtension(),
'pymdownx.caret',
'pymdownx.tilde']
log.debug('list of md extensions: (%s)',
', '.join([e if isinstance(e, str) else type(e).__name__
for e in exts]))
return Markdown(extensions=exts, output_format='html5')
}
},
"root": {"level": "INFO", "handlers": ["console"]},
}
# MARKDOWNIFY
# -------------------------------------------------------------------
from apps.blog.utils.markdown_prism import PrismCodeExtension
from markdown_checklist.extension import ChecklistExtension
from markdown_katex.extension import KatexExtension
MARKDOWNIFY = {
"default": {
"MARKDOWN_EXTENSIONS": [
PrismCodeExtension(),
ChecklistExtension(),
KatexExtension(),
],
"STRIP": False,
"BLEACH": False,
},
"comment": {
"WHITELIST_TAGS": [],
"WHITELIST_ATTRS": [],
"WHITELIST_STYLES": [],
"WHITELIST_PROTOCOLS": [],
"LINKIFY_TEXT": {
"PARSE_URLS": True,
"PARSE_EMAIL": True,
"CALLBACKS": [],
"SKIP_TAGS": [],
"""
# Usage:
# shell> python markdown2html.py path/to/file.md path/to/output/dir
import sys
import commands
import web
import markdown
# https://github.com/FND/markdown-checklist
from markdown_checklist.extension import ChecklistExtension
# Markdown extensions
MD_EXTENSIONS = ['toc', 'meta', 'extra', 'footnotes', 'admonition',
'tables', 'attr_list', ChecklistExtension()]
# Get file name
filename = sys.argv[1]
# Get file name without file extension
filename_without_ext = filename.split('/')[-1].replace('.md', '')
# Get output directory
output_dir = sys.argv[2]
# Get other options and convert them to a dict.
args = sys.argv[3:]
cmd_opts = {}
for arg in args:
if '=' in arg:
(var, value) = arg.split('=')
def markdown(value):
"""Convert plain text to HTML."""
return Markup(md2(value, extensions=[ChecklistExtension()]))