def _addList(self, parent, obj, actions, group, level):
for child in obj.syntax(group=group):
if child.removed:
continue
h = tokens.Heading(parent,
level=level,
string=unicode(child.fullpath.strip('/')))
# TODO: systems prefix is needed to be unique, there must be a better way
url = os.path.join('systems', child.markdown())
a = autolink.AutoLink(h, url=url)
materialicon.IconToken(a,
icon=u'input',
style="padding-left:10px;")
SyntaxToken(parent,
syntax=child,
actions=actions,
objects=True,
subsystems=False,
groups=[group] if group else [],
level=level)
self._addList(parent, child, actions, group, level + 1)
def testExactError(self, mock_log):
link = autolink.AutoLink(None, page='core.md', exact=True)
res = self.render(link, renderer=base.HTMLRenderer())
# TODO: Use assertLogs in python 3.4
self.assertIn("Unable to locate a page that ends with the name 'core.md'",
mock_log.call_args[0][0])
def testBookmark(self):
link = autolink.AutoLink(None, page='core.md', bookmark='unordered-nested-lists')
res = self.render(link, renderer=base.HTMLRenderer())
self.assertHTMLTag(res, 'body', size=1)
self.assertHTMLTag(res(0), 'a', size=3, href='extensions/core.html#unordered-nested-lists')
self.assertHTMLString(res(0)(0), 'Nested')
self.assertHTMLString(res(0)(1), ' ')
self.assertHTMLString(res(0)(2), 'lists')
res = self.render(link, renderer=base.MaterializeRenderer())
self.assertHTMLTag(res, 'div', size=1)
self.assertHTMLTag(res(0), 'a', size=3, href='extensions/core.html#unordered-nested-lists')
self.assertHTMLString(res(0)(0), 'Nested')
self.assertHTMLString(res(0)(1), ' ')
self.assertHTMLString(res(0)(2), 'lists')
res = self.render(link, renderer=base.RevealRenderer())
self.assertHTMLTag(res, 'div', size=1)
self.assertHTMLTag(res(0), 'a', size=3, href='extensions/core.html#unordered-nested-lists')
self.assertHTMLString(res(0)(0), 'Nested')
self.assertHTMLString(res(0)(1), ' ')
self.assertHTMLString(res(0)(2), 'lists')
res = self.render(link, renderer=base.LatexRenderer())
self.assertSize(res, 1)
self.assertLatex(res(0), 'Command', 'hyperref')
self.assertLatexArg(res(0), 0, 'Bracket', 'unordered-nested-lists')
self.assertLatexString(res(0)(0), 'Nested')
self.assertLatexString(res(0)(1), ' ')
self.assertLatexString(res(0)(2), 'lists')
def testBookmarkAlternative(self):
link = autolink.AutoLink(None,
page='not_a_file.md',
bookmark='not-a-bookmark',
alternative='core.md#unordered-nested-lists')
self._testBookmarkHelper(link)
def testExactAlternative(self):
link = autolink.AutoLink(None,
page='not_a_file.md',
alternative='extensions/core.md',
exact=True)
self._testLinkHelper(link)
def testOptionalAlternative(self):
link = autolink.AutoLink(None,
page='not_a_file.md',
alternative='not_a_file.md',
optional=True)
self._testOptionalHelper(link)
def createToken(self, parent, info, page):
design = collections.defaultdict(list)
category = self.settings.get('category')
if category == '_empty_':
return parent
for requirements in self.extension.requirements(category).values():
for req in requirements:
for d in req.design:
try:
node = self.translator.findPage(d)
design[node].append(req)
except exceptions.MooseDocsException:
msg = "Failed to locate the design page '{}'".format(d)
LOG.critical(common.report_error(msg,
req.filename,
req.design_line,
' '.join(req.design),
traceback.format_exc(),
'SQA ERROR'))
for node, requirements in design.items():
matrix = SQARequirementMatrix(parent)
heading = SQARequirementMatrixHeading(matrix, category=category)
autolink.AutoLink(heading, page=str(node.local))
for req in requirements:
self._addRequirement(matrix, info, page, req, requirements)
return parent
def testURLAlternative(self):
link = autolink.AutoLink(None,
page='not_a_file.md',
alternative='https://www.google.com/')
core.Word(link, content='Google')
res = self.render(link, renderer=base.HTMLRenderer())
self.assertHTMLTag(res, 'body', size=1)
self.assertHTMLTag(res(0),
'a',
href='https://www.google.com/',
string='Google')
res = self.render(link, renderer=base.MaterializeRenderer())
self.assertHTMLTag(res, 'div', size=1)
self.assertHTMLTag(res(0),
'a',
href='https://www.google.com/',
string='Google')
res = self.render(link, renderer=base.RevealRenderer())
self.assertHTMLTag(res, 'div', size=1)
self.assertHTMLTag(res(0),
'a',
href='https://www.google.com/',
string='Google')
def _addRequirement(self, parent, info, page, req):
reqname = "{}:{}".format(req.path, req.name) if req.path != '.' else req.name
item = SQARequirementMatrixItem(parent, label=req.label, reqname=reqname)
self.reader.tokenize(item, req.text, page, MooseDocs.INLINE, info.line, report=False)
for token in anytree.PreOrderIter(item):
if token.name == 'ErrorToken':
msg = common.report_error("Failed to tokenize SQA requirement.",
req.filename,
req.text_line,
req.text,
token['traceback'],
'SQA TOKENIZE ERROR')
LOG.critical(msg)
p = core.Paragraph(item)
tokens.String(p, content='Specification: ')
content = common.read(req.filename)
floats.create_modal_link(p,
string=reqname,
content=core.Code(None, language='text', content=content),
title=str(req.filename))
p = core.Paragraph(item)
tokens.String(p, content='Documentation: ')
filename = getattr(req, info['subcommand'])
autolink.AutoLink(p, page=str(filename))
def _addRequirement(self, parent, info, page, req):
item = SQARequirementMatrixItem(parent, requirement=req)
self.reader.tokenize(item,
req.text,
page,
MooseDocs.INLINE,
info.line,
report=False)
for token in anytree.PreOrderIter(item):
if token.name == 'ErrorToken':
msg = common.report_error(
"Failed to tokenize SQA requirement.", req.filename,
req.text_line, req.text, token['traceback'],
u'SQA TOKENIZE ERROR')
LOG.critical(msg)
p = core.Paragraph(item)
tokens.String(p, content=u'Specification: ')
with codecs.open(req.filename, encoding='utf-8') as fid:
content = fid.read()
floats.create_modal_link(p,
string=u"{}:{}".format(
req.path, req.name),
content=core.Code(None,
language=u'text',
content=content),
title=unicode(req.filename))
p = core.Paragraph(item)
tokens.String(p, content=u'Details: ')
filename = u'{}/{}.md'.format(req.path, req.name)
autolink.AutoLink(p, page=unicode(filename))
def createToken(self, parent, info, page):
category = self.settings.get('category')
suffix = self.settings.get('suffix')
return autolink.AutoLink(parent,
page=u'sqa/{}_{}.md'.format(category, suffix),
optional=True,
warning=True)
def testBookmarkWrong(self):
link = autolink.AutoLink(None, page='core.md', bookmark='wrong')
res = self.render(link, renderer=base.HTMLRenderer())
self.assertHTMLTag(res, 'body', size=1)
self.assertHTMLTag(res(0),
'a',
string='extensions/core.html#wrong',
href='extensions/core.html#wrong',
class_='moose-error')
res = self.render(link, renderer=base.MaterializeRenderer())
self.assertHTMLTag(res, 'div', size=1)
self.assertHTMLTag(res(0),
'a',
string='extensions/core.html#wrong',
href='extensions/core.html#wrong',
class_='moose-error')
res = self.render(link, renderer=base.RevealRenderer())
self.assertHTMLTag(res, 'div', size=1)
self.assertHTMLTag(res(0),
'a',
string='extensions/core.html#wrong',
href='extensions/core.html#wrong',
class_='moose-error')
res = self.render(link, renderer=base.LatexRenderer())
self.assertSize(res, 1)
self.assertLatexString(res(0), '_text_')
def testURLAlternativeError(self, mock_log):
link = autolink.AutoLink(None, page='not_a_file.md', alternative='https://www.google.com/')
res = self.render(link, renderer=base.HTMLRenderer())
# TODO: Use assertLogs in python 3.4
self.assertIn("URLs cannot be used as an alternative for automatic shortcut links. " \
"Please use the '[text](link alternative=foo)' syntax instead.",
mock_log.call_args[0][0])
def testMinimal(self):
link = autolink.AutoLink(None, page='core.md')
self._testLinkHelper(link)
res = self.render(link, renderer=base.LatexRenderer())
self.assertSize(res, 1)
self._assertLatex(res(0))
def testExact(self):
link = autolink.AutoLink(None, page='extensions/core.md', exact=True)
self._testLinkHelper(link)
res = self.render(link, renderer=base.LatexRenderer())
self.assertSize(res, 1)
self._assertLatex(res(0))
def testOptional(self):
link = autolink.AutoLink(None, page='not_a_file.md', optional=True)
self._testOptionalHelper(link)
res = self.render(link, renderer=base.LatexRenderer())
self.assertSize(res, 1)
self.assertLatexString(res(0), 'not_a_file.md')
def createToken(self, parent, info, page):
suffix = self.settings['suffix']
ul = core.UnorderedList(parent)
for category in self.extension.get('categories'):
fname = '{}_{}.md'.format(category, suffix)
if not page.local.endswith(fname):
autolink.AutoLink(core.ListItem(ul), page=u'sqa/{}'.format(fname),
optional=True, warning=True, class_='moose-sqa-dependency')
return parent
def testAlternative(self):
link = autolink.AutoLink(None, page='not_a_file.md', alternative='core.md')
self._testLinkHelper(link)
res = self.render(link, renderer=base.LatexRenderer())
self.assertSize(res, 1)
self.assertLatexString(res(0), "Warning: The 'alternative' setting for automatic links " \
"has no effect on LaTeX renderers.")
def createHTML(self, parent, token, page):
p = html.Tag(parent, 'p', string='Design: ', class_='moose-sqa-items')
for design in token['design']:
node = self.findDesign(token['filename'], design, token['line'])
if node is not None:
link = autolink.AutoLink(None, page=page)
link.info = token.info
self.createHTMLHelper(p, link, page, node)
else:
html.Tag(p, 'a', string=str(design), class_='moose-sqa-error')
def _addList(self, parent, info, page, obj, level):
for child in obj.syntax(group=self.settings['group']):
if child.removed:
continue
url = os.path.join('syntax', child.markdown())
h = core.Heading(parent, level=level)
autolink.AutoLink(h, page=url, string=unicode(child.fullpath.strip('/')))
super(SyntaxCompleteCommand, self).createTokenFromSyntax(parent, info, page, child)
self._addList(parent, info, page, child, level + 1)
def _addRequirement(self, parent, info, page, req, requirements):
item = SQARequirementMatrixItem(parent,
label=unicode(req.label),
satisfied=req.satisfied,
id_=req.path)
self.reader.tokenize(item, req.text, page)
if self.settings['link']:
if self.settings['link-spec']:
p = core.Paragraph(item)
tokens.String(p, content=u'Specification: ')
with codecs.open(req.filename, encoding='utf-8') as fid:
content = fid.read()
floats.create_modal_link(
p,
url=u"#",
title=tokens.String(None, content=unicode(req.filename)),
content=core.Code(None, language=u'text', code=content),
string=u"{}:{}".format(req.path, req.name),
tooltip=False)
if self.settings['link-design'] and req.design:
p = core.Paragraph(item)
tokens.String(p, content=u'Design: ')
for design in req.design:
autolink.AutoLink(p, page=unicode(design))
if self.settings['link-issues'] and req.issues:
p = core.Paragraph(item)
tokens.String(p, content=u'Issues: ')
for issue in req.issues:
if issue.startswith('#'):
url = u"https://github.com/idaholab/moose/issues/{}".format(
issue[1:])
else:
url = u"https://github.com/idaholab/moose/commit/{}".format(
issue[1:])
core.Link(p, url=url, string=unicode(issue))
core.Space(p)
if self.settings['link-prerequisites'] and req.prerequisites:
labels = []
for prereq in req.prerequisites:
for other in requirements:
if other.name == prereq:
labels.append(other.label)
p = core.Paragraph(item)
tokens.String(p,
content=u'Prerequisites: {}'.format(
' '.join(labels)))
def testBookmark(self):
link = autolink.AutoLink(None, page='core.md', bookmark='unordered-nested-lists')
self._testBookmarkHelper(link)
res = self.render(link, renderer=base.LatexRenderer())
self.assertSize(res, 1)
self.assertLatex(res(0), 'Command', 'hyperref')
self.assertLatexArg(res(0), 0, 'Bracket', 'unordered-nested-lists')
self.assertLatexString(res(0)(0), 'Nested')
self.assertLatexString(res(0)(1), ' ')
self.assertLatexString(res(0)(2), 'lists')
def testLocalLinkAlternative(self):
link = autolink.AutoLink(None, page='not_a_file.md', alternative='#bookmark')
res = self.render(link, renderer=base.HTMLRenderer())
self.assertHTMLTag(res, 'body', size=1)
self.assertHTMLTag(res(0), 'a', string='_text_#bookmark')
res = self.render(link, renderer=base.MaterializeRenderer())
self.assertHTMLTag(res, 'div', size=1)
self.assertHTMLTag(res(0), 'a', string='_text_#bookmark')
res = self.render(link, renderer=base.RevealRenderer())
self.assertHTMLTag(res, 'div', size=1)
self.assertHTMLTag(res(0), 'a', string='_text_#bookmark')
def testOptional(self):
link = autolink.AutoLink(None, page='not_a_file.md', optional=True)
res = self.render(link, renderer=base.HTMLRenderer())
self.assertHTMLTag(res, 'body', string='_text_')
res = self.render(link, renderer=base.MaterializeRenderer())
self.assertHTMLTag(res, 'div', string='_text_')
res = self.render(link, renderer=base.RevealRenderer())
self.assertHTMLTag(res, 'div', string='_text_')
res = self.render(link, renderer=base.LatexRenderer())
self.assertSize(res, 1)
self.assertLatexString(res(0), '_text_')
def createToken(self, parent, info, page):
suffix = self.settings['suffix']
category = self.settings['category']
if category == '_empty_':
depends = self.extension.get('categories').keys()
else:
depends = self.extension.dependencies(category) or \
self.extension.get('categories').keys()
ul = core.UnorderedList(parent)
for dep in depends:
if dep != category:
fname = '{}_{}.md'.format(dep, suffix)
autolink.AutoLink(core.ListItem(ul), page='sqa/{}'.format(fname),
optional=True, warning=True, class_='moose-sqa-dependency')
return parent
def createToken(self, parent, info, page):
design = collections.defaultdict(list)
for requirements in self.extension.requirements.itervalues():
for req in requirements:
for d in req.design:
node = self.translator.findPage(d)
design[node].append(req)
for node, requirements in design.iteritems():
matrix = SQARequirementMatrix(parent) #, heading=link)
heading = SQARequirementMatrixHeading(matrix)
autolink.AutoLink(heading, page=unicode(node.fullpath))
for req in requirements:
self._addRequirement(matrix, info, page, req, requirements)
return parent
def _addList(self, parent, info, page, obj, level):
gs = self.settings['groups']
groups = set(gs.split()) if gs else set(obj.groups)
for child in obj.syntax():
if child.removed:
continue
if child.groups.intersection(groups):
url = os.path.join('syntax', child.markdown())
h = core.Heading(parent, level=level, id_=self.settings['id'])
autolink.AutoLink(h, page=url, string=unicode(child.fullpath.strip('/')))
SyntaxListCommand.createTokenFromSyntax(self, parent, info, page, child)
self._addList(parent, info, page, child, level + 1)
def testExact(self):
link = autolink.AutoLink(None, page='extensions/core.md', exact=True)
res = self.render(link, renderer=base.HTMLRenderer())
self.assertHTMLTag(res, 'body', size=1)
self._assertHTML(res(0))
res = self.render(link, renderer=base.MaterializeRenderer())
self.assertHTMLTag(res, 'div', size=1)
self._assertHTML(res(0))
res = self.render(link, renderer=base.RevealRenderer())
self.assertHTMLTag(res, 'div', size=1)
self._assertHTML(res(0))
res = self.render(link, renderer=base.LatexRenderer())
self.assertSize(res, 1)
self._assertLatex(res(0))
def createLatex(self, parent, token, page):
latex.Command(parent, 'newline', start='\n', end='\n')
latex.String(parent, content='Design:~', escape=False)
no_seperator = True
for design in token['design']:
if not no_seperator:
latex.String(parent, content='; ')
no_seperator = False
node = self.findDesign(design, token)
if node:
link = autolink.AutoLink(None, page=page)
link.info = token.info
self.createLatexHelper(parent, link, page, node)
else:
latex.Command(parent, 'textcolor', args=[latex.Brace(string='red')], string=design)
def createLatex(self, parent, token, page):
prev = token.previous
if prev and prev.name != 'RenderSQARequirementDetails':
latex.Command(parent, 'newline', start='\n', end='\n')
latex.String(parent, content='Design:~', escape=False)
no_seperator = True
for design in token['design']:
if not no_seperator:
latex.String(parent, content='; ')
no_seperator = False
node = self.findDesign(token['filename'], design, token['line'])
if node:
link = autolink.AutoLink(None, page=page)
link.info = token.info
self.createLatexHelper(parent, link, page, node)
else:
latex.Command(parent, 'textcolor', args=[latex.Brace(string='red')], string=design)
