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 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 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 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'))
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
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 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 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>' )
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 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 DisclaimerElement(Element): loader = XMLFile( FilePath( os.path.join(get_public_static_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 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 [def_stmt, ' ', name, 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 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
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
def __init__(self, templateName): super(PageElement, self).__init__() self.loader = XMLFile( getModule(__name__).filePath.sibling( u"{name}.xhtml".format(name=templateName) ) )
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]
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)
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)
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): """ @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)
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)
class MainElement(Element): loader = XMLFile(FilePath('templates/template.xml')) def __init__(self, name): self._name = name @renderer def name(self, request, tag): return self._name
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)
class WidgetsElement(Element): loader = XMLFile(FilePath("iteration-1.xml")) widgetData = ["gadget", "contraption", "gizmo", "doohickey"] @renderer def widgets(self, request, tag): for widget in self.widgetData: yield tag.clone().fillSlots(widgetName=widget)
class ExampleElement(Element): loader = XMLFile('slots-attributes-1.xml') @renderer def person_profile(self, request, tag): # Note how convenient it is to pass these attributes in! tag.fillSlots(person_name='Luke', profile_image_url='http://example.com/user.png') return tag
class WidgetsElement(Element): loader = XMLFile(FilePath('iteration-1.xml')) widgetData = ['gadget', 'contraption', 'gizmo', 'doohickey'] @renderer def widgets(self, request, tag): for widget in self.widgetData: yield tag.clone().fillSlots(widgetName=widget)
class FunctionChild(Element): loader = XMLFile(util.templatefile('function-child.html')) def __init__(self, docgetter, ob, functionExtras): self.docgetter = docgetter self.ob = ob self._functionExtras = functionExtras @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): if self.ob.decorators: decorators = [ast_pp.pp(dec) for dec in self.ob.decorators] else: decorators = [] if self.ob.kind == "Class Method" \ and 'classmethod' not in decorators: decorators.append('classmethod') elif self.ob.kind == "Static Method" \ and 'staticmethod' not in decorators: decorators.append('staticmethod') if decorators: decorator = [('@' + dec, tags.br()) for dec in decorators] else: decorator = () return decorator @renderer def functionName(self, request, tag): return [self.ob.name, '(', signature(self.ob.argspec), '):'] @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)
class ExampleElement(Element): loader = XMLFile(FilePath('template-1.xml')) @renderer def header(self, request, tag): return tag('<<<Header>>>!') @renderer def footer(self, request, tag): return tag('>>>"Footer!"<<<', id='<"fun">')
class ConfigElement(Element): loader = XMLFile(os.path.join(htmldir, "index.html")) def __init__(self, config): self._config = config @renderer def config(self, request, tag): tag.fillSlots(cosmos_config=self._config) return tag
class ExampleElement(Element): loader = XMLFile(FilePath('template-1.xml')) @renderer def header(self,request,tag): return tag('Header') @renderer def footer(self,request,tag): return tag('Footer.')