def links(self, request, tag):
     ds = self.root.edits(self.ob)
     therange = range(len(ds))
     rev = therange[self.rev]
     ul = tags.ul()
     for i in therange:
         li = tags.li()
         if i:
             u = URLPath.fromRequest(request)
             u = u.sibling('diff')
             u.query = urllib.urlencode({
                 'ob': self.ob.fullName(),
                 'revA': i-1,
                 'revB': i,
                 })
             li(tags.a(href=str(u))("(diff)"))
         else:
             li("(diff)")
         li(" - ")
         if i == len(ds) - 1:
             label = "Latest"
         else:
             label = str(i)
         if i == rev:
             li(label)
         else:
             u = URLPath.fromRequest(request)
             u.query = urllib.urlencode({
                 'rev': str(i),
                 'ob': self.ob.fullName(),
                 })
             li(tags.a(href=str(u))(label))
         li(' - ' + ds[i].user + '/' + ds[i].time)
         ul(li)
     return tag(ul)

    def render_POST(self, request):
        uri = request.args.get('uri', [])
        if not uri or not tahoeRegex.match(uri[0]):
            return self.render_GET(request)
        ext = request.args.get('ext', [])

        b64uri = base64.urlsafe_b64encode(uri[0])
        extension = ''
        if ext and ext[0]:
            extension = '.' + ext[0].lstrip('.')
        if uri[0] not in self.shortdb:
            while True:
                short = crockford.b32encode(os.urandom(9)).lower()
                if short not in self.shortdb:
                    break
            self.shortdb[short] = uri[0]
            self.shortdb[uri[0]] = short
            self.shortdb.sync()
        else:
            short = self.shortdb[uri[0]]

        if request.args.get('api', []):
            return '/' + short + extension

        body = tags.p(
            tags.a('long url', href=b64uri + extension), '; ',
            tags.a('medium url', href='/' + uri[0] + extension), '; ',
            tags.a('short url', href=short + extension))
        return renderElement(request, body)

 def getAuthedLink(self, account):
     return tags.span(
         tags.a(
             tags.span(
                 account.getDisplayName(), class_="persona-link-text"),
             href="/members/account", class_="account-link"),
         " | ",
         tags.a(
             tags.span("Sign out", class_="persona-link-text"),
             href="#logout", id="persona-logout-link"),
         id="member-links")

    def builder_row(self, bn, req, branches, num_builds):
        status = self.getStatus(req)
        builder = status.getBuilder(bn)
        state = builder.getState()[0]
        if state == 'building':
            state = 'idle'
        row = tags.tr()
        builderLink = path_to_builder(req, builder)
        row(tags.td(class_="box %s" % (state,))
                   (tags.a(href=builderLink)(bn)))

        builds = sorted([
            build for build in builder.getCurrentBuilds()
            if set(map_branches(branches)) & builder._getBuildBranches(build)
            ], key=lambda build: build.getNumber(), reverse=True)

        builds.extend(builder.generateFinishedBuilds(
            map_branches(branches), num_builds=num_builds))
        if builds:
            for b in builds:
                url = path_to_build(req, b)
                try:
                    label = b.getProperty("got_revision")
                except KeyError:
                    label = None
                # Label should never be "None", but sometimes
                # buildbot has disgusting bugs.
                if not label or label == "None" or len(str(label)) > 20:
                    label = "#%d" % b.getNumber()
                if b.isFinished():
                    text = b.getText()
                else:
                    when = b.getETA()
                    if when:
                        text = [
                            "%s" % (formatInterval(when),),
                            "%s" % (time.strftime(
                                "%H:%M:%S",
                                time.localtime(time.time() + when)),)
                        ]
                    else:
                        text = []

                row(tags.td(
                    align="center",
                    bgcolor=_backgroundColors[b.getResults()],
                    class_=("LastBuild box ", build_get_class(b)))([
                        (element, tags.br)
                        for element
                        in [tags.a(href=url)(label)] + text]))
        else:
            row(tags.td(class_="LastBuild box")("no build"))

        return row

 def footer_right(self, request, tag):
     """
     '(c) 2014-2016 ',
     tags.a('Open Hive', href='http://open-hive.org/'), ' and ',
     tags.a('Hiveeyes', href='https://hiveeyes.org/docs/system/'), '. ',
     """
     return tag(tags.p(
         'Powered by ',
         tags.a('Kotori', href='https://getkotori.org/'), ', ',
         tags.a('InfluxDB', href='https://github.com/influxdata/influxdb'), ', ',
         tags.a('dygraphs', href='http://dygraphs.com/'), ' and ',
         tags.a('DataTables', href='https://datatables.net/'), '.'
     ))

        def generateTabsAndContent(results):
            """
            results is a dictionary whose keys are normalized ASCII chars and
            whose values are the original (possible unicode) chars that map to
            the ASCII ones.
            """
            tabs = []
            contents = []
            for asciiLetter in sorted(results.keys()):
                if not asciiLetter:
                    continue
                for letter in sorted(results[asciiLetter]):
                    tab = tags.li(
                        tags.a(
                            letter.upper(),
                            href="#l%s" % letter,
                            **{"data-toggle": "tab"})
                        )
                    tabs.append(tab)
                    content = tags.div(
                        tags.p("holding content"),
                        class_="tab-pane",
                        id="l%s" % letter)
                    contents.append(content)

            return tags.div(
                tags.ul(tabs, class_="nav nav-tabs"),
                tags.div(contents, class_="tab-content"),
                class_="tabbable tabs-left")

 def getSignInLink(self):
     return tags.span(
         tags.a(
             tags.span("Persona Sign-in", class_="persona-link-text"),
             href="#login", id="persona-login-link",
             class_="persona-button dark"),
         id="persona-login")

def formatPrincipals(principals):
    """
    Format a list of principals into some twisted.web.template DOM objects.
    """
    def recordKey(principal):
        try:
            record = principal.record
        except AttributeError:
            try:
                record = principal.parent.record
            except:
                return None
        return (record.recordType, record.shortNames[0])


    def describe(principal):
        if hasattr(principal, "record"):
            return " - %s" % (principal.record.fullName,)
        else:
            return ""

    return formatList(
        tags.a(href=principal.principalURL())(
            str(principal), describe(principal)
        )
        for principal in sorted(principals, key=recordKey)
    )

 def getCopyright(self):
     year = meta.startingYear
     thisYear = datetime.now().year
     mailTo = "mailto:%s" % config.salesEmail
     if thisYear > year:
         year = "%s - %s" % (year, thisYear)
     return ("© %s " % year, tags.a(meta.author, href=mailTo))

 def _showDirectory(self, request, dirinfo):
     children = dirinfo[1]['children']
     body = tags.ul(*[
         tags.li(tags.a(name + ('/' if info[0] == 'dirnode' else ''),
                        href='/' + info[1]['ro_uri']))
         for name, info in children.iteritems()
     ])
     renderElement(request, body)

 def hist(self, data, request):
     u = URLPath.fromRequest(request)
     u = u.sibling('diff')
     u.query = urllib.urlencode({
         'ob': data.obj.fullName(),
         'rev': data.rev,
         })
     return tags.a(href=str(u))("(hist)")

 def stanForOb(self, ob, summary=False):
     current_docstring = self.currentDocstringForObject(ob)
     if summary:
         return epydoc2stan.doc2stan(
             ob.doctarget, summary=True,
             docstring=current_docstring)[0]
     r = [tags.div(epydoc2stan.doc2stan(ob.doctarget,
                                        docstring=current_docstring)[0]),
          tags.a(href="edit?ob="+ob.fullName())("Edit"),
          " "]
     if ob.doctarget in self.editsbyob:
         r.append(tags.a(href="history?ob="+ob.fullName())(
             "View docstring history (",
             str(len(self.editsbyob[ob.doctarget])),
             " versions)"))
     else:
         r.append(tags.span(class_='undocumented')("No edits yet."))
     return r

 def lineno(self, request, tag):
     if not self.has_lineno_col:
         return ()
     if hasattr(self.child, 'linenumber'):
         line = str(self.child.linenumber)
         if self.child.sourceHref:
             line = tags.a(href=self.child.sourceHref)(line)
         return tag.clear()(line)
     else:
         return ()

 def getDropdown(self, title, url, cssClass):
     elements = []
     if title == "About":
         links = urls.aboutDropDown
     for text, url, type in links:
         if type == const.DIVIDER:
             element = tags.li(class_="divider")
         elif type == const.HEADER:
             element = tags.li(text, class_="nav-header")
         else:
             element = tags.li(tags.a(text, href=url))
         elements.append(element)
     return tags.li(
         tags.a(
             title, tags.b(class_="caret"),
             href="#", class_="dropdown-toggle",
             **{"data-toggle": "dropdown"}),
         tags.ul(elements, class_="dropdown-menu"),
         class_=cssClass)

    def from_dashboard(cls, dashboard):
        url = '/%s' % (dashboard.config['name'])

        if 'share_id' in dashboard.config:
            shared_url = '/shared/%s' % dashboard.config['share_id']
            shared_url_tag = tags.a(shared_url, href=shared_url)
        else:
            shared_url_tag = ''

        return cls(dashboard.config['title'], url, shared_url_tag)

def maybeShortenList(system, label, lst, idbase):
    lst2 = []
    for name in lst:
        o = system.allobjects.get(name)
        if o is None or o.isVisible:
            lst2.append(name)
    lst = lst2
    if not lst:
        return None
    def one(item):
        if item in system.allobjects:
            return taglink(system.allobjects[item])
        else:
            return item
    def commasep(items):
        r = []
        for item in items:
            r.append(one(item))
            r.append(', ')
        del r[-1]
        return r
    p = [label]
    if len(lst) <= 5 or not system.options.htmlshortenlists:
        p.extend(commasep(lst))
    else:
        p.extend(commasep(lst[:3]))
        q = [', ']
        q.extend(commasep(lst[3:]))
        q.append(tags.span(class_='showIfJS')[
            ' ',
            tags.a(href="#",
                   onclick="showAndHide('%s');"%idbase,
                   class_="jslink")
            ['(hide last %d again)'%len(lst[3:])]])
        p.append(tags.span(id=idbase, class_='hideIfJS')[q])
        p.append(tags.span(id=idbase+'Link', class_='showIfJS')[
            ' ',
            tags.a(href="#",
                   onclick="hideAndShow('%s');"%idbase,
                   class_="jslink")
            ['... and %d more'%len(lst[3:])]])
    return p

    def render_GET(self, request):
        applications = []
        for app in self.registry.applications.values():
            link = tags.a(tags.tt(app.name), ' at ', tags.tt(app.path.path),
                          href=app.name)
            applications.append(tags.li(link))

        body = tags.body(
            tags.p('Here are your applications:'),
            tags.ul(*applications))
        return renderElement(request, body)

 def letterlinks(self, request, tag):
     letterlinks = []
     for initial in sorted(self.initials):
         if initial == self.my_letter:
             letterlinks.append(initial)
         else:
             letterlinks.append(tags.a(href='#'+initial)(initial))
         letterlinks.append(' - ')
     if letterlinks:
         del letterlinks[-1]
     return tag(letterlinks)

 def dictionaries(self, request, tag):
     """
     """
     elements = []
     for dictionary in const.dictionaries:
         name = utils.getDictionaryName(dictionary)
         url = const.urls["dictionary"].replace(
             const.urlParams["dictionary"], dictionary)
         elements.append(
             tags.li(tags.a(name, href=url)))
     return tag(elements)

    def test_serializedAttributeWithTagWithAttribute(self):
        """
        Similar to L{test_serializedAttributeWithTag}, but for the additional
        complexity where the tag which is the attribute value itself has an
        attribute value which contains bytes which require substitution.
        """
        flattened = self.assertFlattensImmediately(
            tags.img(src=tags.a(href='<>&"')),
            '<img src="&lt;a href=' "&quot;&amp;lt;&amp;gt;&amp;amp;&amp;quot;&quot;&gt;" '&lt;/a&gt;" />',
        )

        # As in checkTagAttributeSerialization, belt-and-suspenders:
        self.assertXMLEqual(XML(flattened).attrib["src"], '<a href="&lt;&gt;&amp;&quot;"></a>')