class MainPage(Element):
loader = XMLFile(templatepath.child('mainpage.html'))
extraContent = XMLFile(csspath.child('lcars.css'))
@renderer
def css_spec(self, _request, tag):
LOG.debug('In css_spec renderer')
l_path = csspath.child('Simple.css')
tag.fillSlots(css_filespec=l_path)
return tag
def alarms(self, request, tag):
"""
dynamically render the alarms
"""
if not self.display_alarms:
return ''
else:
alarm_snippet = XMLFile(
FilePath("TrackerDash/snippets/green_alarm.xml"))
return alarm_snippet.load()
class Workspace(Element):
"""
WARNING:
The names of the @athena.expose methods seem to have to match the js file name.
They are called from browser when elements are attached to the workspace.
"""
loader = XMLFile(templatepath.child('workspaceElement.html'))
#-----------------
# Calls from browser JS to load an element (fragment)
"""
# NOTE! Tne name of the def MUST be the same as the widget name as used in workspace.js attachWidget's first argument.
"""
def inject_404(self):
LOG.info("404 called from browser")
# f = FourOfour()
# f.setFragmentParent(self)
# return f
@renderer
def login(self, _p_params):
l_element = web_login.LoginElement(self)
l_element.setFragmentParent(self)
return l_element
@renderer
def rootMenu(self, _p_params):
l_element = web_rootMenu.RootMenuElement(self)
l_element.setFragmentParent(self)
return l_element
class ClassIndexPage(Element):
filename = 'classIndex.html'
loader = XMLFile(templatefile('summary.html'))
def __init__(self, system):
self.system = system
@renderer
def title(self, request, tag):
return tag.clear()("Class Hierarchy")
@renderer
def stuff(self, request, tag):
t = tag
anchors = set()
for b, o in findRootClasses(self.system):
if isinstance(o, model.Class):
t(subclassesFrom(self.system, o, anchors))
else:
item = tags.li(b)
if o:
ul = tags.ul()
for sc in sorted(o, key=_lckey):
ul(subclassesFrom(self.system, sc, anchors))
item(ul)
t(item)
return t
@renderer
def heading(self, request, tag):
return tag.clear()("Class Hierarchy")
class UndocumentedSummaryPage(Element):
filename = 'undoccedSummary.html'
loader = XMLFile(templatefile('summary.html'))
def __init__(self, system):
self.system = system
@renderer
def title(self, request, tag):
return tag.clear()("Summary of Undocumented Objects")
@renderer
def heading(self, request, tag):
return tag.clear()("Summary of Undocumented Objects")
@renderer
def stuff(self, request, tag):
undoccedpublic = [
o for o in self.system.orderedallobjects
if o.isVisible and not hasdocstring(o)
]
undoccedpublic.sort(key=lambda o: o.fullName())
for o in undoccedpublic:
tag(tags.li(o.kind, " - ", taglink(o)))
return tag
class MainTemplate(Element):
loader = XMLFile(FilePath('templates/main.xml'))
def __init__(self, title, user, body=None):
Element.__init__(self)
self.titleText = title
self.user = user
self.bodyElement = body
@renderer
def body(self, req, tag):
if self.bodyElement == None:
return tag('No content on this page sorry...')
return self.bodyElement
@renderer
def titleTag(self, req, tag):
return tag(self.titleText)
@renderer
def userSpot(self, req, tag):
if self.user != None and self.user.loggedIn:
return UserInfoTemplate(self.user)
return RawXML(
'<ul class="nav navbar-nav navbar-right"><li><a href="/login">Login</a></li><li><a href="/register">Register</a></li></ul>'
)
def __init__(self, template, data, snapshot, maxDepth = 0):
Element.__init__(self)
self.loader = XMLFile(FilePath(template))
self.chart_data = data
self.snapshot_id = snapshot
if maxDepth > 0:
self.chart_options['maxDepth'] = maxDepth
class NameIndexPage(Element):
filename = 'nameIndex.html'
loader = XMLFile(templatefile('nameIndex.html'))
def __init__(self, system):
self.system = system
self.initials = {}
for ob in self.system.orderedallobjects:
if ob.isVisible:
self.initials.setdefault(ob.name[0].upper(), []).append(ob)
@renderer
def title(self, request, tag):
return tag.clear()("Index Of Names")
@renderer
def heading(self, request, tag):
return tag.clear()("Index Of Names")
@renderer
def index(self, request, tag):
r = []
for i in sorted(self.initials):
r.append(LetterElement(TagLoader(tag), self.initials, i))
return r
def test_filename(self) -> None:
"""
An L{XMLFile} with a filename returns a useful repr().
"""
fname = "/tmp/fake.xml" # deprecated
self.assertEqual(f"<XMLFile of {fname!r}>",
repr(XMLFile(fname))) # type: ignore[arg-type]
class WidgetsElement(Element):
loader = XMLFile(FilePath('MusicLister.xml'))
@renderer
def widgets(self, request, tag):
for widget in self.widgetData:
yield tag.clone().fillSlots(href=widget['href'], content=widget['content'])
class DisclaimerElement(Element):
loader = XMLFile(
FilePath(
os.path.join(_get_startup_folder(),
'_login_disclaimer_banner.html')))
def __init__(self, banner):
super(DisclaimerElement, self).__init__()
self._set_loader(banner)
self._banner_filename = banner or "_login_disclaimer_banner.html"
def _set_loader(self, banner):
if banner:
current_path = os.path.dirname(os.path.abspath(__file__))
banner_file_path = os.path.join(current_path, "..", "..", "..",
banner)
self.loader = XMLFile(FilePath(banner_file_path))
def render(self, request):
try:
return super(DisclaimerElement, self).render(request)
except SAXParseException:
return [
"Invalid XML template format for %s." % self._banner_filename
]
except IOError:
return [
"Disclaimer banner file %s could not be read or does not exit."
% self._banner_filename
]
class DiffElement(Element):
def __init__(self, root, ob, origob, editA, editB):
self.root = root
self.ob = ob
self.origob = origob
self.editA = editA
self.editB = editB
@renderer
def title(self, request, tag):
return tag("Viewing differences between revisions ",
str(self.editA.rev), " and ", str(self.editB.rev), " of ",
u"\N{LEFT DOUBLE QUOTATION MARK}" +
self.origob.fullName() +
u"\N{RIGHT DOUBLE QUOTATION MARK}")
@renderer
def diff(self, request, tag):
fd = FileDiff(self.ob.parentMod)
fd.apply_edit(self.root.editsbyob[self.ob][0], self.editA)
fd.reset()
fd.apply_edit(self.editA, self.editB)
return tags.pre(fd.diff())
loader = XMLFile(util.templatefile('diff.html'))
def test_file(self) -> None:
"""
An L{XMLFile} with a file object returns a useful repr().
"""
fobj = StringIO("not xml") # deprecated
self.assertEqual(f"<XMLFile of {fobj!r}>",
repr(XMLFile(fobj))) # type: ignore[arg-type]
class IndexPage(Element):
filename = 'index.html'
loader = XMLFile(templatefile('index.html'))
def __init__(self, system):
self.system = system
@renderer
def project_link(self, request, tag):
if self.system.options.projecturl:
return tags.a(href=self.system.options.projecturl)(
self.system.projectname)
else:
return self.system.projectname
@renderer
def project(self, request, tag):
return self.system.projectname
@renderer
def recentChanges(self, request, tag):
return ()
@renderer
def problemObjects(self, request, tag):
return ()
@renderer
def onlyIfOneRoot(self, request, tag):
if len(self.system.rootobjects) != 1:
return []
else:
root, = self.system.rootobjects
return tag.clear()("Start at ", taglink(root), ", the root ",
root.kind.lower(), ".")
@renderer
def onlyIfMultipleRoots(self, request, tag):
if len(self.system.rootobjects) == 1:
return []
else:
return tag
@renderer
def roots(self, request, tag):
r = []
for o in self.system.rootobjects:
r.append(tag.clone().fillSlots(root=taglink(o)))
return r
@renderer
def rootkind(self, request, tag):
rootkinds = {}
for o in self.system.rootobjects:
rootkinds[o.kind.lower() + 's'] = 1
return tag.clear()('/'.join(sorted(rootkinds)))
@renderer
def buildtime(self, request, tag):
return self.system.buildtime.strftime("%Y-%m-%d %H:%M:%S")
class ChildTable(Element):
loader = XMLFile(util.templatefilepath('table.html'))
last_id = 0
def __init__(self, docgetter, ob, children):
self.docgetter = docgetter
self.system = ob.system
self.children = children
ChildTable.last_id += 1
self._id = ChildTable.last_id
self.ob = ob
@renderer
def id(self, request, tag):
return 'id'+str(self._id)
@renderer
def rows(self, request, tag):
return [
TableRow(
TagLoader(tag),
self.docgetter,
self.ob,
child)
for child in self.children]
class AttributeChild(Element):
loader = XMLFile(util.templatefilepath('attribute-child.html'))
def __init__(self, docgetter, ob):
self.docgetter = docgetter
self.ob = ob
@renderer
def class_(self, request, tag):
class_ = self.ob.css_class
if self.ob.parent is not self.ob:
class_ = 'base' + class_
return class_
@renderer
def functionAnchor(self, request, tag):
return self.ob.fullName()
@renderer
def shortFunctionAnchor(self, request, tag):
return self.ob.name
@renderer
def attribute(self, request, tag):
return self.ob.name
@renderer
def functionBody(self, request, tag):
return self.docgetter.get(self.ob)
class MxitResponse(Element):
loader = XMLFile(FilePath(MXIT_RESOURCES.path('templates/response.xml')))
def __init__(self, message, loader=None):
self.header, self.items = ResponseParser.parse(
message['content'] or u'')
super(MxitResponse, self).__init__(loader or self.loader)
@renderer
def render_header(self, request, tag):
return tag(self.header)
@renderer
def render_body(self, request, tag):
if not self.items:
return ''
return tag
@renderer
def render_item(self, request, tag):
for index, text in self.items:
yield tag.clone().fillSlots(index=str(index), text=text)
def flatten(self):
return flattenString(None, self)
class FunctionChild(Element):
loader = XMLFile(util.templatefilepath('function-child.html'))
def __init__(self, docgetter, ob, functionExtras):
self.docgetter = docgetter
self.ob = ob
self._functionExtras = functionExtras
@renderer
def class_(self, request, tag):
class_ = self.ob.css_class
if self.ob.parent is not self.ob:
class_ = 'base' + class_
return class_
@renderer
def functionAnchor(self, request, tag):
return self.ob.fullName()
@renderer
def shortFunctionAnchor(self, request, tag):
return self.ob.name
@renderer
def decorator(self, request, tag):
return list(format_decorators(self.ob))
@renderer
def functionDef(self, request, tag):
def_stmt = 'async def' if self.ob.is_async else 'def'
name = self.ob.name
if name.endswith('.setter') or name.endswith('.deleter'):
name = name[:name.rindex('.')]
return [
tags.span(def_stmt, class_='py-keyword'), ' ',
tags.span(name, class_='py-defname'), signature(self.ob), ':'
]
@renderer
def sourceLink(self, request, tag):
if self.ob.sourceHref:
return tag.fillSlots(sourceHref=self.ob.sourceHref)
else:
return ()
@renderer
def functionExtras(self, request, tag):
return self._functionExtras
@renderer
def functionBody(self, request, tag):
return self.docgetter.get(self.ob)
@renderer
def functionDeprecated(self, request, tag):
if hasattr(self.ob, "_deprecated_info"):
return (tags.div(self.ob._deprecated_info, role="alert", class_="deprecationNotice alert alert-warning"),)
else:
return ()
class AccountRecoveryPage(Element):
loader = XMLFile(
FilePath(
os.path.join(get_public_static_folder(), 'account_recovery.html')))
def __init__(self):
super(AccountRecoveryPage, self).__init__()
def test_filename(self):
"""
An L{XMLFile} with a filename returns a useful repr().
"""
fname = "/tmp/fake.xml"
self.assertEqual("<XMLFile of {!r}>".format(fname),
repr(XMLFile(fname)))
class UploadResultsElement(status.UploadResultsRendererMixin):
loader = XMLFile(FilePath(__file__).sibling("upload-results.xhtml"))
def __init__(self, upload_results):
super(UploadResultsElement, self).__init__()
self._upload_results = upload_results
def upload_results(self):
return defer.succeed(self._upload_results)
@renderer
def done(self, req, tag):
d = self.upload_results()
d.addCallback(lambda res: "done!")
return d
@renderer
def uri(self, req, tag):
d = self.upload_results()
d.addCallback(lambda res: res.get_uri())
return d
@renderer
def download_link(self, req, tag):
d = self.upload_results()
d.addCallback(
lambda res: tags.a("/uri/" + res.get_uri(),
href="/uri/" + urllib.quote(res.get_uri())))
return d
def setLoader(self, templateDir="", templateFile=""):
if not templateDir:
templateDir = self.templateDir
if not templateFile:
templateFile = self.templateFile
template = FilePath("%s/%s" % (templateDir, templateFile))
self.loader = XMLFile(template.path)
class ConfigElement(Element):
loader = XMLFile(os.path.join(htmldir, "index.html"))
@staticmethod
def gatherArgs(opts):
meta = {}
with open(cosmosConfigFile(opts['home'])) as f:
config = f.read()
gr = '/usr/src/app/lib/git-revision.txt'
if os.path.exists(gr):
with open(gr) as f:
meta['package_git'] = f.read().strip()
else:
with os.popen('git rev-parse --short HEAD') as f:
sha = f.read().strip()
with os.popen('git diff --quiet || echo -dirty') as f:
meta['package_git'] = sha + f.read().strip()
pj = '/usr/src/app/package.json'
pjson = {}
if os.path.exists(pj):
with open(pj) as f:
pjson = json.load(f)
else:
pjpath = None
# Walk upwards from the current directory.
pj = os.path.abspath('package.json')
while pj != pjpath:
pjpath = pj
if os.path.exists(pjpath):
with open(pjpath) as f:
pjson = json.load(f)
break
pj = os.path.join(os.path.dirname(pjpath), '../package.json')
pj = os.path.abspath(pj)
meta['package_version'] = pjson.get('version', 'unknown')
meta['package_name'] = pjson.get('name', 'cosmic-swingset')
repo = pjson.get('repository',
'https://github.com/Agoric/cosmic-swingset')
cleanRev = meta['package_git'].replace('-dirty', '')
link = repo + '/commit/' + cleanRev
meta['package_repo'] = link
return [config, meta]
def __init__(self, config, meta):
self._config = config
self._meta = meta
@renderer
def config(self, request, tag):
tag.fillSlots(cosmos_config=self._config)
return tag
@renderer
def meta(self, request, tag):
tag.fillSlots(**self._meta)
return tag
class BackupAccountPage(Element):
loader = XMLFile(
FilePath(
os.path.join(get_protected_static_folder(),
'backup_account.html')))
def __init__(self):
super(BackupAccountPage, self).__init__()
def loaderFactory(self) -> ITemplateLoader:
"""
@return: an L{XMLString} constructed with a filename that points to a
file containing C{self.templateString}.
"""
fp = FilePath(self.mktemp())
fp.setContent(self.templateString.encode("utf8"))
return XMLFile(fp.path) # type: ignore[arg-type]
def __init__(self, templateName):
super(PageElement, self).__init__()
self.loader = XMLFile(
getModule(__name__).filePath.sibling(
u"{name}.xhtml".format(name=templateName)
)
)
def loaderFactory(self):
"""
@return: an L{XMLString} constructed with a filename that points to a
file containing C{self.templateString}.
"""
fp = FilePath(self.mktemp())
fp.setContent(self.templateString.encode('utf8'))
return XMLFile(fp.path)
def loaderFactory(self):
"""
@return: an L{XMLString} constructed with a L{FilePath} pointing to a
file that contains C{self.templateString}.
"""
fp = FilePath(self.mktemp())
fp.setContent(self.templateString.encode("utf8"))
return XMLFile(fp)
def __init__(self, template, data, labels, snapshot, processes, field):
Element.__init__(self)
self.loader = XMLFile(FilePath(template))
self.chart_data = data
self.labels = labels
self.snapshot_id = snapshot
self.process_ids = processes
self.field = field
class Template(Element):
loader = XMLFile(self.infonode_template)
@renderer
def description(self, request, tag):
html = verifier.getDescription()
if not IRenderable.providedBy(html): html = Verbatim(html)
return tag(html)
class WidgetsElement(Element):
loader = XMLFile(FilePath("subviews-1.xml"))
widgetData = ["gadget", "contraption", "gizmo", "doohickey"]
@renderer
def widgets(self, request, tag):
for widget in self.widgetData:
yield WidgetElement(TagLoader(tag), widget)
def content(self, request, tag):
"""
get the content for the configuration page
"""
log_content = XMLFile(FilePath("TrackerDash/snippets/logs.xml"))
return log_content.load()
def content(self, request, tag):
"""
get the content for the configuration page
"""
footer_snippet = XMLFile(FilePath("TrackerDash/snippets/new_dash.xml"))
return footer_snippet.load()
def footer(self, request, tag):
"""
dynamically render the footer
"""
footer_snippet = XMLFile(FilePath("TrackerDash/snippets/footer.xml"))
return footer_snippet.load()
