def handleMatch(self, m, data):
el = etree.Element(INDEXED_WORDS_TAG)
el.set('class', INDEXED_WORDS_CLASSNAME)
el.set('data-book-index', self.unescape(
m.group(1).strip())) # Use unescape to remove placeholders
el.text = AtomicString(m.group(1).strip())
return el, m.start(0), m.end(0)
def handleMatch(self, m):
"""Handle pattern match."""
gist_id = m.group('gist_id')
gist_file = m.group('filename')
gist_elem = etree.Element('div')
gist_elem.set('class', 'gist')
script_elem = etree.SubElement(gist_elem, 'script')
noscript_elem = etree.SubElement(gist_elem, 'noscript')
try:
if gist_file:
script_elem.set('src', GIST_FILE_JS_URL.format(
gist_id, gist_file))
raw_gist = (self.get_raw_gist_with_filename(
gist_id, gist_file))
else:
script_elem.set('src', GIST_JS_URL.format(gist_id))
raw_gist = (self.get_raw_gist(gist_id))
# Insert source as <pre/> within <noscript>
pre_elem = etree.SubElement(noscript_elem, 'pre')
pre_elem.text = AtomicString(raw_gist)
except GistFetchException as e:
LOGGER.warn(e.message)
warning_comment = etree.Comment(' WARNING: {0} '.format(e.message))
noscript_elem.append(warning_comment)
return gist_elem
def handleMatch(self, m):
node = etree.Element(None)
text = ''
for group in self.groups:
text += m.group(group)
node.text = AtomicString(text)
return node;
def run(self, parent, blocks):
sibling = self.lastChild(parent)
block = blocks.pop(0)
block, theRest = self.detab(block)
block = block.rstrip()
block_is_html = False
if "<div " in block or "</" in block or "<span " in block:
block_is_html = True
if (sibling is not None and sibling.tag == "div"):
# The previous block was a code block. As blank lines do not start
# new code blocks, append this block to the previous, adding back
# linebreaks removed from the split into a list.
block_is_html = block_is_html and not isinstance(sibling.text, AtomicString)
block = u'\n'.join([sibling.text, block])
output = sibling
else:
# This is a new codeblock. Create the elements and insert text.
output = markdown.util.etree.SubElement(parent, 'div', {'class': 'code-output'})
# If not HTML, add the `pre` class so that we know to render output as raw text
if not block_is_html and 'pre' not in output.get('class', 'code-output'):
output.set('class', ' '.join([output.get('class', ''), 'pre']))
output.text = "{}\n".format(block) if block_is_html else AtomicString("{}\n".format(block))
if theRest:
# This block contained unindented line(s) after the first indented
# line. Insert these lines as the first block of the master blocks
# list for future processing.
blocks.insert(0, theRest)
def handleMatch(self, match):
"""
process settings associated with !buildstatus markdown
"""
url = match.group(2)
# A tuple separating specific MOOSE documentation features from HTML styles
settings = self.getSettings(match.group(3))
# Create parent div, and set any allowed CSS
parent_div = self.applyElementSettings(etree.Element('div'), settings)
parent_div.set('class', 'moose-buildstatus')
child_div = etree.SubElement(parent_div, 'div')
jquery_script = etree.SubElement(parent_div, 'script')
build_status_script = etree.SubElement(parent_div, 'script')
jquery_script.set('src', 'http://code.jquery.com/jquery-1.11.0.min.js')
# We need to inform SmartyPants to not format for paragraph use
build_status_script.text = \
AtomicString('$(document).ready(function(){ $("#buildstatus").load("%s");});' % (url))
# Set some necessary defaults for our child div
child_div.set('id', 'buildstatus')
# Set any additional allowed CSS
return parent_div
def handleMatch(self, match: Match) -> Element:
groups = match.groupdict()
element: Element = markdown.util.etree.Element('span')
element.set('class', 'counter')
element.set('title', 'counter')
element.text = AtomicString(groups.get('numbers'))
return element
def handleMatch(self, m, data):
node = Element('script')
node.set('type', self._content_type)
node.text = AtomicString(m.group(2))
if self._add_preview:
node = _wrap_node(node, m.group(0), 'span')
return node, m.start(0), m.end(0)
def safe_concat(a, b):
''' to deal with cases when a is None '''
if isinstance(a, AtomicString):
return AtomicString(a + b)
else:
# otherwise a is str-like or none
return (a or '') + b
def _wrap_node(node, preview_text, wrapper_tag):
if not self.getConfig('add_preview'):
return node
preview = etree.Element('span', {'class': 'MathJax_Preview'})
preview.text = AtomicString(preview_text)
wrapper = etree.Element(wrapper_tag)
wrapper.extend([preview, node])
return wrapper
def append(text, sibling):
preElement = sibling.find("*/pre")
currentCode = preElement.text
lines = [x for x in currentCode.split('\n') if x]
lines.append(text)
preElement.text = AtomicString('%s' % ('\n'.join(lines)))
def _wrap_node(node, preview_text, wrapper_tag):
if not self.getConfig("add_preview"):
return node
preview = etree.Element("span", {"class": "MathJax_Preview"})
preview.text = AtomicString(preview_text)
wrapper = etree.Element(wrapper_tag)
wrapper.extend([preview, node])
return wrapper
def handleMatch(self, m):
el = etree.Element("a")
href = m.group(2)
if not re.match('^(ftp|https?)://', href, flags=re.IGNORECASE):
href = 'http://%s' % href
el.set('href', self.unescape(href))
el.text = AtomicString(m.group(2))
return el
def handleMatch(self, m):
subsc = m.group(3)
text = subsc
el = etree.Element('sub')
el.text = AtomicString(text)
return el
def handleMatch(self, m):
el = etree.Element('span')
el.set('class', 'type')
types = m.group(3)
# Make sure types are shown as type1 | type2
types = re.sub(' or ', ' | ', types)
types = re.sub(r'(?<=\w)[|](?=\w)', ' | ', types)
el.text = AtomicString(types)
return el
def make_link(self, category, obj, url, text):
"""Make an <a> element
Override this to set custom attributes, e.g. title.
"""
el = etree.Element('a')
el.set('href', url)
el.text = AtomicString(text)
return el
def handle_match_inline(m):
node = etree.Element('script')
node.set('type', self._get_content_type(m.group(2)))
if m.group(2) in self.asciimath_delimiters:
text = self._fix_html_entites(m.group(3))
if self.getConfig('asciimath_escape'):
node.text = AtomicString(self._process_escape(text))
else:
node.text = AtomicString(text)
elif m.group(2) in self.latexmath_delimiters:
text = self._fix_latex(m.group(3))
if self.getConfig('latexmath_escape'):
node.text = AtomicString(self._process_escape(text))
else:
node.text = AtomicString(text)
else:
text = m.group(3)
node.text = AtomicString(text)
return _wrap_node(node, m.group(2) + text + m.group(4), 'span')
def handleMatch(self, m, data):
for value, is_block in zip(m.groups(), (False, True, True)):
if value:
break
script = etree.Element('script', type='math/tex' + ('; mode=display' if is_block else ''))
preview = etree.Element('span', {'class': 'MathJax_Preview'})
preview.text = script.text = AtomicString(value)
wrapper = etree.Element('span')
wrapper.extend([preview, script])
return wrapper, m.start(0), m.end(0)
def run(self, parent, blocks):
block = blocks.pop(0)
m = re.fullmatch(self.RE_DISPLAY_BLOCK, block, re.DOTALL)
e = etree.SubElement(parent, 'script')
e.set('type', 'math/tex; mode=display')
e.text = AtomicString(self.ELEM_TEXT_BEGIN + m.group(1).strip('\n') +
self.ELEM_TEXT_END)
return True
def handleMatch(self, m):
from pokedex.db import tables, util
start, label, category, target, end = m.groups()
try:
table = dict(
ability=tables.Ability,
item=tables.Item,
location=tables.Location,
move=tables.Move,
pokemon=tables.PokemonSpecies,
type=tables.Type,
form=tables.PokemonForm,
)[category]
except KeyError:
obj = name = target
url = self.factory.identifier_url(category, obj)
else:
session = self.session
if table is tables.PokemonForm:
form_ident, pokemon_ident = target.split()
query = session.query(table)
query = query.filter(
tables.PokemonForm.form_identifier == form_ident)
query = query.join(tables.PokemonForm.pokemon)
query = query.join(tables.Pokemon.species)
query = query.filter(
tables.PokemonSpecies.identifier == pokemon_ident)
else:
query = session.query(table)
query = query.filter(table.identifier == target)
try:
obj = query.one()
except Exception:
obj = name = target
url = self.factory.identifier_url(category, obj)
else:
url = self.factory.object_url(category, obj)
url = url or self.factory.identifier_url(category, target)
name = None
# Translations can be incomplete; in which case we want to use
# a fallback.
if table in [tables.Type] and self.string_language:
# Type wants to be localized to the text language
name = obj.name_map.get(self.string_language)
if not name and self.game_language:
name = obj.name_map.get(self.game_language)
if not name:
name = obj.name
if url:
el = self.factory.make_link(category, obj, url, label or name)
else:
el = etree.Element('span')
el.text = AtomicString(label or name)
return el
def handleMatch(self, m):
ref = m.group(3)
s = ref.split('.')
if len(s) == 2:
refurl = ('/ref/%s#%s') % (s[0], ref)
else:
refurl = ('#%s') % (s[0])
el = etree.Element('a')
el.text = AtomicString(ref)
el.set('href', refurl)
return el
def render_html_span(token):
# intentionally let Python-Markdown handle this
# because its html parser is stronger!
#
# Example:
# # Hello <small>world</small>
# mistletoe: [Hello, <small>, world, </small>]
# PyMD: [Hello, <small>world</small>]
# which result wrong TOC title generation, but I
# don't want to change that plugin myself
return AtomicString(token.content)
def render_quote(self, token):
el = etree.Element('blockquote')
el.text = '\n'
self._suppress_ptag_stack.append(False)
self.append_elems(el, self.render_inner_join(token))
self.append_newline_inside(el)
# remove duplicate newlines, dealing with empty blockquote, e.g.
# test #202: '>\n' -> '<blockquote>\n</blockquote>\n'
if not el and el.text == '\n\n':
el.text = AtomicString('\n')
self._suppress_ptag_stack.pop()
return el
def run(self, parent, blocks):
block = blocks.pop(0)
text = block
# Parse configuration params
m = self.RE.search(block)
delimiter = m.group('delimiter')
imgformat = m.group('format') if m.group(
'format') else self.config['format']
classes = m.group('classes') if m.group(
'classes') else self.config['classes']
alt = m.group('alt') if m.group('alt') else self.config['alt']
title = m.group('title') if m.group('title') else self.config['title']
# Read blocks until end marker found
end_re = self.RE_END1 if delimiter == '::uml::' else self.RE_END2
while blocks and not end_re.search(block):
block = blocks.pop(0)
text += '\n' + block
else:
if not blocks:
raise RuntimeError("UML block not closed")
# Remove block header and footer
text = re.sub(self.RE, "", re.sub(end_re, "", text))
text = "\n".join(text.split('\n'))
diagram = self.generate_uml_image(text, imgformat)
p = etree.SubElement(parent, 'p')
if imgformat == 'png':
data = 'data:image/png;base64,{0}'.format(
base64.b64encode(diagram).decode('ascii'))
img = etree.SubElement(p, 'img')
img.attrib['src'] = data
img.attrib['classes'] = classes
img.attrib['alt'] = alt
img.attrib['title'] = title
elif imgformat == 'svg':
# Firefox handles only base64 encoded SVGs
data = 'data:image/svg+xml;base64,{0}'.format(
base64.b64encode(diagram).decode('ascii'))
img = etree.SubElement(p, 'img')
img.attrib['src'] = data
img.attrib['classes'] = classes
img.attrib['alt'] = alt
img.attrib['title'] = title
elif imgformat == 'txt':
#logger.debug(diagram)
pre = etree.SubElement(parent, 'pre')
code = etree.SubElement(pre, 'code')
code.attrib['class'] = 'text'
code.text = AtomicString(diagram)
def run(self, root):
if (not self.pelican_katex_extension.katex_needed):
return root
katex_script = etree.Element('script')
katex_script.set('type', 'text/javascript')
katex_script.text = AtomicString(
self.pelican_katex_extension.getConfig('katex_script'))
root.append(katex_script)
self.pelican_katex_extension.katex_needed = False
return root
def render_block_code(self, token):
el_pre = etree.Element('pre')
el_code = etree.SubElement(el_pre, 'code')
if token.language:
el_code.set('class', 'language-{}'.format(self.escape_html(token.language)))
# to comply with the format using in PythonMarkdown.
# or it may break in plugins like codehilite!!
code_text = (html.escape(token.children[0].content)
.replace(''', "'")
# FIXME: breaks commonmark test suite #176
.replace('"', '"'))
# protect inside content from being interpreted
el_code.text = AtomicString(code_text)
return el_pre
def run(self, root):
# If no mathjax was present, then exit
if (not self.pelican_mathjax_extension.mathjax_needed):
return
# Add the mathjax script to the html document
mathjax_script = etree.Element('script')
mathjax_script.set('type','text/javascript')
mathjax_script.text = AtomicString(self.pelican_mathjax_extension.getConfig('mathjax_script'))
root.append(mathjax_script)
# Reset the boolean switch to false so that script is only added
# to other pages if needed
self.pelican_mathjax_extension.mathjax_needed = False
def run(self, parent, blocks):
block = blocks.pop(0)
assert block.startswith("@show")
files = block[5:].split()
for f in files:
file_container = etree.SubElement(parent, "div")
file_container.set("class", "file_container")
filename_container = etree.SubElement(file_container, "div")
filename_container.text = f
filename_container.set('class', 'filename')
hunk_container = etree.SubElement(file_container, "pre")
hunk_container.set('class', 'show')
daddy = etree.SubElement(hunk_container, "code")
daddy.text = AtomicString("".join(
iter(open(self.srcdir + "/new/" + f))))
def handleMatch(self, m):
jinja_block = m.group(2)
try:
# render returns a unicode object
# html = render_template_string(m.group(2))
html = ENV.from_string(m.group(2)).render()
place_holder = self.markdown.htmlStash.store(html)
return place_holder
except Exception as e:
traceback.print_exc()
el = etree.Element('em')
el.text = AtomicString('Error %s in rendering %s' %
(e, m.group(2)))
return el
def create(self, text, number, parent):
container = etree.SubElement(parent, 'div')
container.set('class', self.config['output_class'])
container.set('data-output', number)
if self.config['show_label']:
label = etree.SubElement(container, 'div')
label.set('class', 'notebook_output_text')
span = etree.SubElement(label, 'span')
span.text = self.config['label_text'].format(number)
output = etree.SubElement(container, 'div')
output.set('class', 'notebook_output_code')
preElement = etree.SubElement(output, 'pre')
preElement.text = AtomicString('%s\n' % text)
def render_inner_join(self, token, delim='\n'):
"""
Render as usual, but join yielded elements with
a newline character in between.
"""
xs = self.render_inner(token)
try:
head = next(xs)
except StopIteration:
# if the iterator is empty, we are done
return
yield head
for x in xs:
yield AtomicString(delim)
yield x
