def test_sourceFragmentElement(self):
        """
        L{_SourceFragmentElement} renders source lines at and around the line
        number indicated by a frame object.
        """
        element = _SourceFragmentElement(
            TagLoader(tags.div(
                    tags.span(render="lineNumber"),
                    tags.span(render="sourceLine"),
                    render="sourceLines")),
            self.frame)

        source = [
            u' \N{NO-BREAK SPACE} \N{NO-BREAK SPACE}message = '
            u'"This is a problem"',

            u' \N{NO-BREAK SPACE} \N{NO-BREAK SPACE}raise Exception(message)',
            u'# Figure out the line number from which the exception will be '
            u'raised.',
        ]
        d = flattenString(None, element)
        d.addCallback(
            self.assertEqual,
            ''.join([
                    '<div class="snippet%sLine"><span>%d</span><span>%s</span>'
                    '</div>' % (
                        ["", "Highlight"][lineNumber == 1],
                        self.base + lineNumber,
                        (u" \N{NO-BREAK SPACE}" * 4 + sourceLine).encode(
                            'utf-8'))
                    for (lineNumber, sourceLine)
                    in enumerate(source)]))
        return d

 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 test(missing):
     plating = Plating(tags=tags.span(slot(Plating.CONTENT)))
     @plating.routed(self.app.route("/"),
                     tags.span(tags.span(render=missing)))
     def no(request):
         return {}
     self.get(b"/")
     [fe] = self.flushLoggedErrors(FlattenerError)
     self.assertIsInstance(fe.value.args[0], MissingRenderMethod)

 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 test_presentation_only_json(self):
     """
     Slots marked as "presentation only" will not be reflected in the
     output.
     """
     plating = Plating(tags=tags.span(slot("title")),
                       presentation_slots={"title"})
     @plating.routed(self.app.route("/"),
                     tags.span(slot("data")))
     def justJson(request):
         return {"title": "uninteresting", "data": "interesting"}
     request, written = self.get(b"/?json=1")
     self.assertEqual(json.loads(written.decode("utf-8")),
                      {"data": "interesting"})

 def test_sourceLineElement(self):
     """
     L{_SourceLineElement} renders a source line and line number.
     """
     element = _SourceLineElement(
         TagLoader(tags.div(
                 tags.span(render="lineNumber"),
                 tags.span(render="sourceLine"))),
         50, "    print 'hello'")
     d = flattenString(None, element)
     expected = (
         u"<div><span>50</span><span>"
         u" \N{NO-BREAK SPACE} \N{NO-BREAK SPACE}print 'hello'</span></div>")
     d.addCallback(
         self.assertEqual, expected.encode('utf-8'))
     return d

 def getCities(self):
     elements = []
     for index, city in enumerate(sorted(config.officeCities)):
         if index >= 1:
             elements.append("·")
         elements.append(tags.span(city, class_="city"))
     return elements

    def test_template_numbers(self):
        """
        Data returned from a plated method may include numeric types (integers,
        floats, and possibly longs), which although they are not normally
        serializable by twisted.web.template, will be converted by plating into
        their decimal representation.
        """
        @page.routed(
            self.app.route("/"),
            tags.div(
                tags.span(slot("anInteger")),
                tags.i(slot("anFloat")),
                tags.b(slot("anLong")),
            ),
        )
        def plateMe(result):
            return {"anInteger": 7,
                    "anFloat": 3.2,
                    "anLong": 0x10000000000000001}

        request, written = self.get(b"/")

        self.assertIn(b"<span>7</span>", written)
        self.assertIn(b"<i>3.2</i>", written)
        self.assertIn(b"<b>18446744073709551617</b>", written)

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 test_failureElementType(self):
     """
     The I{type} renderer of L{FailureElement} renders the failure's
     exception type.
     """
     element = FailureElement(
         self.failure, TagLoader(tags.span(render="type")))
     d = flattenString(None, element)
     d.addCallback(
         self.assertEqual, "<span>exceptions.Exception</span>")
     return d

 def test_failureElementValue(self):
     """
     The I{value} renderer of L{FailureElement} renders the value's exception
     value.
     """
     element = FailureElement(
         self.failure, TagLoader(tags.span(render="value")))
     d = flattenString(None, element)
     d.addCallback(
         self.assertEqual, b'<span>This is a problem</span>')
     return d

    def render(self, request):
        setRequestCatalog(request)
        form = self.form(request)
        request.write('<!DOCTYPE html>\n')
        if request.method == "POST" and form.validate():
            content = tags.span("Form Valid!")
        else:
            content = FormElement(form)

        done = flatten(request, Layout(content), request.write)
        done.addCallback(lambda r: request.finish())
        return server.NOT_DONE_YET

 def test_prime_directive_return(self):
     """
     Nothing within these Articles Of Federation shall authorize the United
     Federation of Planets to alter the return value of a callable by
     applying a decorator to it...
     """
     exact_result = {"ok": "some nonsense value"}
     @page.routed(self.app.route("/"),
                  tags.span(slot("ok")))
     def plateMe(request):
         return exact_result
     self.assertIdentical(plateMe(None), exact_result)

 def test_template_html(self):
     """
     Rendering a L{Plating.routed} decorated route results in templated
     HTML.
     """
     @page.routed(self.app.route("/"),
                  tags.span(slot("ok")))
     def plateMe(request):
         return {"ok": "test-data-present"}
     request, written = self.get(b"/")
     self.assertIn(b'<span>test-data-present</span>', written)
     self.assertIn(b'<title>default title unchanged</title>', written)

        def entry_rendered(entry):
            if entry.system_entry:
                attrs_entry = attrs_entry_system
            else:
                attrs_entry = attrs_entry_user

            return tags.div(
                tags.span(
                    str(entry.created),
                    u", ",
                    entry.author,
                    **attrs_timestamp
                ),
                ":",
                tags.br(),
                tags.span(
                    entry.text,
                    **attrs_entry_text
                ),
                **attrs_entry
            )

 def test_frameElementFunction(self):
     """
     The I{function} renderer of L{_FrameElement} renders the line number
     associated with the frame object used to initialize the
     L{_FrameElement}.
     """
     element = _FrameElement(
         TagLoader(tags.span(render="function")),
         self.frame)
     d = flattenString(None, element)
     d.addCallback(
         self.assertEqual, b"<span>lineNumberProbeAlsoBroken</span>")
     return d

 def test_frameElementLineNumber(self):
     """
     The I{lineNumber} renderer of L{_FrameElement} renders the line number
     associated with the frame object used to initialize the
     L{_FrameElement}.
     """
     element = _FrameElement(
         TagLoader(tags.span(render="lineNumber")),
         self.frame)
     d = flattenString(None, element)
     d.addCallback(
         self.assertEqual, b"<span>" + intToBytes(self.base + 1) + b"</span>")
     return d

 def mediumName(self, ob):
     r = [super(ClassPage, self).mediumName(ob)]
     zipped = zip(self.ob.rawbases, self.ob.bases, self.ob.baseobjects)
     if zipped:
         r.append('(')
         for i, (n, m, o) in enumerate(zipped):
             if o is None:
                 r.append(tags.span(title=m)(n))
             else:
                 r.append(taglink(o, n))
             if i != len(zipped)-1:
                 r.append(', ')
         r.append(')')
     return r

 def test_failureElementType(self):
     """
     The I{type} renderer of L{FailureElement} renders the failure's
     exception type.
     """
     element = FailureElement(
         self.failure, TagLoader(tags.span(render="type")))
     d = flattenString(None, element)
     if _PY3:
         exc = b"builtins.Exception"
     else:
         exc = b"exceptions.Exception"
     d.addCallback(
         self.assertEqual, b"<span>" + exc + b"</span>")
     return d

 def test_frameElementFilename(self):
     """
     The I{filename} renderer of L{_FrameElement} renders the filename
     associated with the frame object used to initialize the
     L{_FrameElement}.
     """
     element = _FrameElement(
         TagLoader(tags.span(render="filename")),
         self.frame)
     d = flattenString(None, element)
     d.addCallback(
         # __file__ differs depending on whether an up-to-date .pyc file
         # already existed.
         self.assertEqual, "<span>" + __file__.rstrip('c') + "</span>")
     return d