def renderOnce(fragmentClass):
    """
    Create L{DEPTH} LiveFragments, each nested within the next, and then render
    the result.
    """
    rname = fragmentClass.__name__[0].lower() + fragmentClass.__name__[1:]
    innerFragment = fragmentClass(docFactory=stan(p(render=directive(rname))["Hello, world."]))
    for i in xrange(DEPTH - 1):
        outerFragment = fragmentClass(docFactory=stan(p(render=directive(rname))[innerFragment]))
        innerFragment.setFragmentParent(outerFragment)
        innerFragment = outerFragment
    render(outerFragment)

	def render_head_tag(self, ctx, data):
		ctx.fillSlots('meta_tags', "")

		## CSS
		stylesheets = []
		color_option = self._get_color_option(ctx)
		global_css_includes = self.global_css_includes + ['zoto_%s.css' % color_option]
		for file in global_css_includes + self.local_css_includes:
			stylesheets += [T.link(type="text/css", rel="stylesheet", href=self.make_css_path(file)), '\n']
		ctx.fillSlots('css_includes', loaders.stan(T.invisible[stylesheets]))

		## alternate links - rss, atom, etc.
		feed_links= [] 
		for feed_url in self.global_feed_includes + self.local_feed_includes:
			feed_links += [T.link(type="application/%s+xml"%feed_url['type'], rel="alternate", href=feed_url['uri']), '\n']
		ctx.fillSlots('feed_includes', loaders.stan(T.invisible[feed_links]))

		## Javascript
		scripts = []
		if aztk_config.setup.get('site', 'environment') in ["sandbox", "development"]:
			for script in self.global_js_includes + self.local_js_includes:
				if script == "core.js":
					for script in js.core_js.scripts:
						scripts += [T.script(type="text/javascript", src=self.make_js_path(script)), '\n']
				elif script == "site.js":
					for script in js.site_js.scripts:
						scripts += [T.script(type="text/javascript", src=self.make_js_path(script)), '\n']
				elif script == "managers.js":
					for script in js.managers_js.scripts:
						scripts += [T.script(type="text/javascript", src=self.make_js_path(script)), '\n']
				elif script == "mochikit.js":
					scripts += [
						T.script(type="text/javascript", src=self.make_js_path("third_party/MochiKit/MochiKit.js")), '\n',
						T.script(type="text/javascript", src=self.make_js_path("third_party/MochiKit/DragAndDrop.js")), '\n',
						T.script(type="text/javascript", src=self.make_js_path("third_party/MochiKit/Sortable.js")), '\n'
					]
				else:
					scripts += [T.script(type="text/javascript", src=self.make_js_path(script)), '\n']
			if self.page_manager_js:
				scripts += [T.script(type="text/javascript", src=self.make_js_path(self.page_manager_js)), '\n']
			ctx.fillSlots('js_includes', loaders.stan(T.invisible[scripts]))
		else:
			for script in self.global_js_includes + self.local_js_includes:
				if script == "mochikit.js":
					scripts += [T.script(type="text/javascript", src=self.make_js_path("third_party/MochiKit/packed/MochiKit.js")), '\n']
				else:
					scripts += [T.script(type="text/javascript", src=self.make_js_path(script)), '\n']
			if self.page_manager_js:
				scripts += [T.script(type="text/javascript", src=self.make_js_path(self.page_manager_js)), '\n']
			ctx.fillSlots('js_includes', loaders.stan(T.invisible[scripts]))

		return ctx

        def _renderPage():
            page = MantissaLivePage(FakeWebSite())
            element = LiveElement(stan(tags.span(render=tags.directive('liveElement'))))
            element.setFragmentParent(page)
            element.jsClass = u'Mantissa.Test.Dummy.DummyWidget'
            page.docFactory = stan([tags.span(render=tags.directive('liveglue')), element])

            ctx = WovenContext()
            req = FakeRequest(headers={'host': self.hostname})
            ctx.remember(req, IRequest)
            page.beforeRender(ctx)
            page.renderHTTP(ctx)
            page._messageDeliverer.close()

 def test_patterned(self):
     """Test fetching a specific part (a pattern) of the document.
     """
     doc = t.div[t.p[t.span(pattern='inner')['something']]]
     df = loaders.stan(doc, pattern='inner')
     self.assertEquals(df.load()[0].tagName, 'span')
     self.assertEquals(df.load()[0].children[0], 'something')

 def speed(self, speed):
     return rend.Page(
         docFactory=loaders.stan(
             tags.html[
                 tags.body(id='body')[
                     "Thanks for taking our survey! You said: %r %r %r" % (
                         self.original[0], self.original[1], speed)]]))

    def test_docFactoryInStanTree(self):

        class Page(rend.Page):

            def __init__(self, included):
                self.included = included
                rend.Page.__init__(self)

            def render_included(self, context, data):
                return self.included
            
            docFactory = loaders.stan(div[invisible(render=directive('included'))])

        doc = '<p>fum</p>'
        temp = self.mktemp()
        f = file(temp, 'w')
        f.write(doc)
        f.close()

        result = deferredRender(Page(loaders.stan(p['fee'])))
        self.assertEquals(result, '<div><p>fee</p></div>')
        result = deferredRender(Page(loaders.htmlstr('<p>fi</p>')))
        self.assertEquals(result, '<div><p>fi</p></div>')
        result = deferredRender(Page(loaders.xmlstr('<p>fo</p>')))
        self.assertEquals(result, '<div><p>fo</p></div>')
        result = deferredRender(Page(loaders.htmlfile(temp)))
        self.assertEquals(result, '<div><p>fum</p></div>')
        result = deferredRender(Page(loaders.xmlfile(temp)))
        self.assertEquals(result, '<div><p>fum</p></div>')

    def test_simple(self):

        doc = div[p['foo'],p['bar']]
        result = unittest.deferredResult(
            rend.Page(docFactory=loaders.stan(doc)).renderString()
            )
        self.assertEquals(result, '<div><p>foo</p><p>bar</p></div>')

        def __init__(self, ctx, restWriter, key, srcId):
            self.restWriter = restWriter

            form = iformal.IForm( ctx )
            u = formal_widgetResourceURLFromContext(ctx, form.name).child(key).child( srcId ).child('_submit')
            self.destId=srcId + '-dest'
            formId=srcId + '-form'

            stan = T.html()[
                T.head()[
                    T.script(type="text/javascript")["""
                    function ReSTTranslate() {
                        dest = document.getElementById('%(destId)s');
                        form = document.getElementById('%(formId)s');
                        src = parent.document.getElementById('%(srcId)s');
                        dest.value = src.value;
                        form.submit();
                    }

                    """%{'srcId':srcId, 'destId':self.destId, 'formId':formId}]
                ],
                T.body()[
                    T.form(id=formId, method="POST", action=u)[
                        T.input(type="hidden", name=self.destId, id=self.destId)
                    ],
                    T.script(type="text/javascript")["ReSTTranslate();"],
                ],
            ]

            self.docFactory = loaders.stan(stan)

    def doRendering(self, fragmentClass):
        """
        Verify that the given fragment class will render without raising an
        exception.
        """
        siteStore = Store()

        loginSystem = LoginSystem(store=siteStore)
        installOn(loginSystem, siteStore)
        p = Product(
            store=siteStore, types=["xmantissa.webadmin.LocalUserBrowser", "xmantissa.signup.SignupConfiguration"]
        )
        account = loginSystem.addAccount(u"testuser", u"localhost", None)
        p.installProductOn(account.avatars.open())
        f = fragmentClass(None, u"testuser", account)

        p = LivePage(docFactory=stan(html[head(render=directive("liveglue")), body(render=lambda ctx, data: f)]))
        f.setFragmentParent(p)

        ctx = WovenContext()
        req = FakeRequest()
        ctx.remember(req, IRequest)

        d = p.renderHTTP(ctx)

        def rendered(ign):
            p.action_close(None)

        d.addCallback(rendered)
        return d

	def render_content(self, ctx, data):
		request = inevow.IRequest(ctx)
		
		ctx.fillSlots('header_bar', self.anon_header) 
		ctx.fillSlots('top_bar', T.div(id="top_bar"))
		ctx.fillSlots('main_content', loaders.stan(T.div(id="manager_hook")))
		return ctx.tag

    def test_blogsRenderer(self):
        """
        Test that L{hyperbola_view.BlogListFragment.blogs} renders a list of blogs.
        """
        site = self.siteStore.findUnique(SiteConfiguration)
        site.hostname = u'blogs.renderer'
        blog1 = self._shareAndGetProxy(self._makeBlurb(FLAVOR.BLOG))
        blog2 = self._shareAndGetProxy(self._makeBlurb(FLAVOR.BLOG))
        blf = hyperbola_view.BlogListFragment(
            athena.LivePage(), self.publicPresence)
        blf.docFactory = loaders.stan(
            tags.div(pattern='blog')[
                tags.span[tags.slot('title')],
                tags.span[tags.slot('link')],
                tags.span[tags.slot('post-url')]])
        tag = tags.invisible
        markup = flat.flatten(tags.div[blf.blogs(None, tag)])
        doc = minidom.parseString(markup)
        blogNodes = doc.firstChild.getElementsByTagName('div')
        self.assertEqual(len(blogNodes), 2)

        for (blogNode, blog) in zip(blogNodes, (blog1, blog2)):
            (title, blogURL, postURL) = blogNode.getElementsByTagName('span')
            blogURL = blogURL.firstChild.nodeValue
            expectedBlogURL = str(websharing.linkTo(blog))
            self.assertEqual(blogURL, expectedBlogURL)
            postURL = postURL.firstChild.nodeValue
            self.assertEqual(
                postURL, 'https://blogs.renderer' + expectedBlogURL + '/post')

    def test_reusedDocFactory(self):
        """
        Test that a docFactory which is used more than once behaves properly
        both times.
        """
        class Page(rend.Page):
            docFactory = loaders.stan(div[invisible(render=directive('included'))])

            def __init__(self, included):
                self.included = included
                rend.Page.__init__(self)

            def render_included(self, context, data):
                return self.included

        p1 = Page(loaders.stan('first'))
        p2 = Page(loaders.xmlstr('<p>second</p>'))

        d = deferredRender(p1)
        def rendered(result):
            self.assertEqual(result, '<div>first</div>')
            return deferredRender(p2)
        d.addCallback(rendered)

        def renderedAgain(result):
            self.assertEqual(result, '<div><p>second</p></div>')
        d.addCallback(renderedAgain)

        return d

 def test_stanPreprocessors(self):
     """
     Test that the stan loader properly passes uncompiled documents to
     preprocessors it is given.
     """
     factory = loaders.stan(
         t.div[t.span['Hello'], t.span['world']])
     return self._preprocessorTest(factory)

 def test_synchronousFlatten(self):
     """
     Flattening a L{Element} with no Deferreds using the old synchronous
     flattener API returns a value synchronously.
     """
     element = Element()
     element.docFactory = stan(["hello, world"])
     self.assertEqual(synchronousFlatten(element), "hello, world")

 def test_simpleStanRendering(self):
     """
     Test that a Element with a simple, static stan document factory
     renders correctly.
     """
     f = Element(docFactory=stan(p["Hello, world."]))
     return self._render(f).addCallback(
         self.assertEqual, "<p>Hello, world.</p>")

 def setUp(self):
     self.d = Deferred()
     self.d2 = Deferred()
     self.r = rend.Page(docFactory=loaders.stan(
         tags.html(data=self.data_later)[
             'Hello ', str, ' and '
             'goodbye ',str,
             tags.span(data=self.data_later2, render=str)]))

    def renderHTTP(self, ctx):

        self.setup()

        #ensure that we are delivered with the correct content type header
        inevow.IRequest(ctx).setHeader("Content-Type",
            "application/vnd.mozilla.xul+xml; charset=%s" % (self.charset,))

        #Do something a bit magical.. glue css/js stuff into the window before
        #any other widgets so they get read first.
        if self.css is not None:
            self.window.children.insert(0,
                htmlns.style(type="text/css")[self.css])
        self.css = None

        for css in self.cssIncludes:
            self.window.children.insert(0,
                htmlns.style(type="text/css", src=css))
        self.cssIncludes = []

        if self.js is not None:
            self.window.children.insert(0,
                htmlns.script(type="text/javascript")[self.js])
        self.js = None

        for js in self.jsIncludes:
            self.window.children.insert(0,
                htmlns.script(type="text/javascript", src=js))
        self.jsIncludes = []

        #We want to have javascript included in this order:
        #   preLiveglue.js
        #   liveglue.js
        #   postLiveglue.ps

        if not self.glueInstalled:

            self.window.children.insert(0, htmlns.script(
                type="text/javascript", src=url.here.child(
                    'javascript').child('postLiveglue.js')))

            self.window.children.insert(0, T.invisible(
                render=T.directive('liveglue')))

            self.window.children.insert(0, htmlns.script(
                type="text/javascript", src=url.here.child(
                    'javascript').child('preLiveglue.js')))

            self.glueInstalled = True

        #.. end magical

        #make sure our XUL tree is loaded and our correct doc type is set
        self.docFactory = loaders.stan([
            T.xml("""<?xml version="1.0"?><?xml-stylesheet href="chrome://global/skin/" type="text/css"?>"""),
            self.window])
        #return our XUL
        return athena.LivePage.renderHTTP(self, ctx)

 def offerings():
     for p in self.offeringPlugins.itervalues():
         data = {'name': p.name, 'description': p.description}
         if p.name not in self.installedOfferings:
             f = UninstalledOfferingFragment(data, self.original, p, docFactory=loaders.stan(uninstalled()))
             f.page = self.page
         else:
             f = rend.Fragment(data, docFactory=loaders.stan(installed()))
         yield f

def renderPlainFragment(fragment):
    """
    same as L{render}, but expects an L{nevow.rend.Fragment} or any
    other L{nevow.inevow.IRenderer}
    """
    page = Page(docFactory=stan(fragment))
    (request, context) = _makeContext()
    page.renderHTTP(context)
    return request.v

 def test_synchronousFlattenError(self):
     """
     If the old flattener encounters an exception while flattening an
     L{IRenderable}, the exception is raised to the caller of the flattener
     API.
     """
     element = Element()
     element.docFactory = stan(invisible(render=directive('foo')))
     self.assertRaises(FlattenerError, synchronousFlatten, element)