class TestFramework(athena.LivePage):
addSlash = True
docFactory = loaders.stan([
tags.xml(DOCTYPE_XHTML),
tags.html[
tags.head(render=tags.directive('liveglue'))[
tags.link(rel='stylesheet', href='livetest.css'),
tags.directive('head')],
tags.body[
tags.invisible(render=tags.directive('runner'))]]])
def __init__(self, testSuite):
super(TestFramework, self).__init__()
self.testSuite = testSuite
self.children = {
'livetest.css': static.File(util.resource_filename('nevow.livetrial', 'livetest.css')),
}
def beforeRender(self, ctx):
self.runner = TestRunner(self.testSuite)
def render_runner(self, ctx, data):
self.runner.setFragmentParent(self)
return self.runner
def render_head(self, ctx, data):
return self.runner.gatherHead()
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 __init__(self, ctx, restWriter, key, srcId):
self.restWriter = restWriter
form = iformal.IForm(ctx)
u = 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)
class ResultsPage(athena.LivePage):
addSlash = True
docFactory = loaders.stan(
tags.html[tags.head(render=tags.directive('liveglue'))[
tags.title["IPython Results"],
tags.link(rel="stylesheet", type="text/css", href="main.css"),
tags.link(rel="stylesheet", type="text/css", href="results.css")],
tags.body[tags.h1["IPython Results"],
tags.div(render=tags.directive('widgets'))]])
def __init__(self, controller):
athena.LivePage.__init__(self)
self.controller = controller
if not self.children:
self.children = {}
self.children["main.css"] = static.File(
util.sibpath(__file__, 'main.css'))
self.children["results.css"] = static.File(
util.sibpath(__file__, 'results.css'))
def render_widgets(self, ctx, data):
w = aw.ResultWidget()
w.setFragmentParent(self)
n1 = results.notifierFromFunction(w.handleResult)
self.controller.addNotifier(n1)
c = aw.CommandWidget(self.controller)
c.setFragmentParent(self)
return ctx.tag[w, tags.br, c]
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 __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)
class WebInterface(athena.LivePage):
docFactory = loaders.stan([tags.raw(xhtml_header),
tags.html(xmlns="http://www.w3.org/1999/xhtml")[
tags.head(render=tags.directive('liveglue')),
tags.body[
tags.div[
tags.div( render = tags.directive( "MainPage" ))
]]]])
MainPage = MainPage()
PLCHMI = PLCHMI
def __init__(self, plcState=False, *a, **kw):
super(WebInterface, self).__init__(*a, **kw)
self.jsModules.mapping[u'WebInterface'] = util.sibpath(__file__, 'webinterface.js')
self.plcState = plcState
self.MainPage.setPLCState(plcState)
def getHMI(self):
return self.MainPage.getHMI()
def LoadHMI(self, hmi, jsmodules):
for name, path in jsmodules.iteritems():
self.jsModules.mapping[name] = os.path.join(WorkingDir, path)
self.MainPage.setPLCStartedHMI(hmi)
def UnLoadHMI(self):
self.MainPage.resetPLCStartedHMI()
def PLCStarted(self):
self.plcState = True
self.MainPage.setPLCState(True)
def PLCStopped(self):
self.plcState = False
self.MainPage.setPLCState(False)
def renderHTTP(self, ctx):
"""
Force content type to fit with SVG
"""
req = inevow.IRequest(ctx)
req.setHeader('Content-type', 'application/xhtml+xml')
return super(WebInterface, self).renderHTTP(ctx)
def render_MainPage(self, ctx, data):
f = self.MainPage
f.setFragmentParent(self)
return ctx.tag[f]
def child_(self, ctx):
self.MainPage.detachFragmentChildren()
return WebInterface(plcState=self.plcState)
def beforeRender(self, ctx):
d = self.notifyOnDisconnect()
d.addErrback(self.disconnected)
def disconnected(self, reason):
self.MainPage.resetHMI()
class MyPage(athena.LivePage):
addSlash = True
docFactory = loaders.stan(T.html[T.head(render=T.directive('liveglue')),
T.body(render=T.directive('myElement'))])
def render_myElement(self, ctx, data):
f = MyElement()
f.setFragmentParent(self)
return ctx.tag[f]
class ReSTPreview(rend.Page):
def __init__(self, ctx, restWriter, key, srcId):
self.restWriter = restWriter
form = iformal.IForm(ctx)
u = 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 child__submit(self, ctx):
args = inevow.IRequest(ctx).args
value = args.get(self.destId, [''])[0]
from docutils.utils import SystemMessage
try:
if self.restWriter:
restValue = self._html_fragment(value, writer=self.restWriter)
else:
restValue = self._html_fragment(value, writer_name='html')
except SystemMessage, e:
restValue = str(e)
stan = T.html()[T.head()[T.style(type="text/css")["""
.system-message {border: 1px solid red; background-color: #FFFFDD; margin: 5px; padding: 5px;}
.system-message-title { font-weight: bold;}
"""]],
T.body()[T.div()[T.xml(restValue)]], ]
self.docFactory = loaders.stan(stan)
return self
def getTemplate(self, resultFormat):
if resultFormat in self.service.templates:
return self.service.getTemplate(resultFormat)
return common.doctypedStan(T.html[
T.head(render=T.directive("commonhead"))[T.title(
render=T.directive("meta"))['title'], ],
T.body(render=T.directive("withsidebar"))[
T.h1(render=T.directive("meta"))['title'],
T.div(class_="result", data=T.directive("result"))[T.invisible(
render=T.directive(resultFormat))]]])
class ControllerPageAthena(athena.LivePage):
"""This is broken"""
chat = None
addSlash = True
docFactory = loaders.stan(
tags.html[tags.head(
render=tags.directive('liveglue')
)[tags.link(rel="stylesheet", type="text/css", href="main.css"),
tags.link(rel="stylesheet", type="text/css", href="controller.css")],
tags.body[tags.h1["IPython Controller"], tags.br,
tags.h2[tags.div(
render=tags.directive('idwidget')), tags.br,
tags.a(href="results")["results"], tags.br,
tags.a(href="status")["status"], tags.br,
tags.a(href="command")["command"], tags.br,
tags.a(href="monitor")["monitor"]],
tags.br,
tags.div(render=tags.directive('chat'))]])
def __init__(self, controller):
athena.LivePage.__init__(self)
self.controller = controller
if not self.children:
self.children = {}
self.children["main.css"] = static.File(
util.sibpath(__file__, 'main.css'))
self.children["controller.css"] = static.File(
util.sibpath(__file__, 'controller.css'))
def render_idwidget(self, ctx, data):
w = aw.IDWidget(self.controller)
w.setFragmentParent(self)
return ctx.tag[w]
def render_chat(self, ctx, data):
self.chat = "NO CHAT"
if self.chat is None:
self.chat = aw.ChatWidget()
self.chat.setFragmentParent(self)
return ctx.tag[self.chat]
def child_results(self, ctx):
return ResultsPage(self.controller)
def child_status(self, ctx):
return StatusPage(self.controller)
def child_command(self, ctx):
return CommandPage(self.controller)
def child_monitor(self, ctx):
return MonitorPage(self.controller)
def goingLive(self, ctx, client):
return self.chat.goingLive(ctx, client)
class ElementRenderingLivePage(LivePage):
"""
Trivial LivePage which renders an instance of a particular element class.
"""
docFactory = stan(html[head(render=directive('liveglue'))[title(
render=directive('title'))], body[div(render=directive('element'))]])
def __init__(self, element):
LivePage.__init__(self)
self.element = element
def render_title(self, ctx, data):
return ctx.tag[self.element.__class__.__name__]
def render_element(self, ctx, data):
self.element.setFragmentParent(self)
return ctx.tag[self.element]
class NotebookPage(athena.LivePage):
addSlash = True
docFactory = loaders.stan(
tags.html[tags.head(
render=tags.directive('liveglue')
)[tags.title["IPython Notebook"],
tags.link(href="notebook.css", rel="stylesheet", type="text/css"), ],
tags.body(render=tags.directive('widget'))])
def __init__(self, controller):
athena.LivePage.__init__(self)
self.controller = controller
if self.children is None:
self.children = {}
self.children["notebook.css"] = static.File(
util.sibpath(__file__, 'notebook.css'))
def render_widget(self, ctx, data):
w = aw.NotebookWidget(self.controller)
w.setFragmentParent(self)
return ctx.tag[w]
def test_rendering(self):
"""
Test that L{webadmin.UserInteractionFragment} renders without raising
any exceptions.
"""
f = UserInteractionFragment(self.browser)
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
class ResultPage(athena.LivePage):
addSlash = True
source = None
CSS = open(basedir+'/ajaxpb.css').read()
start = CSS.find('height', CSS.find('resultOut'))
stop = CSS.find('\n', start)
css = CSS[:start]+'height: 30em;\n'+CSS[stop:]
docFactory = loaders.stan(tags.html[
tags.head(render=tags.directive('liveglue')),
tags.style(type="text/css")[css],
tags.body(render=tags.directive('resultElement'))])
def __init__(self, source):
athena.LivePage.__init__(self)
self.source = source
def render_resultElement(self, ctx, data):
f = ResultElement()
f.setFragmentParent(self)
reactor.callLater(1, self.source.addGatherer, f)
return ctx.tag[f]
def _render(self, element):
"""
Put the given L{IRenderer} provider into an L{athena.LivePage} and
render it. Return a Deferred which fires with the request object used
which is an instance of L{nevow.testutil.FakeRequest}.
"""
p = LivePage(docFactory=stan(html[head(
render=directive('liveglue')), body[invisible(
render=lambda ctx, data: element)]]))
element.setFragmentParent(p)
ctx = WovenContext()
req = FakeRequest()
ctx.remember(req, IRequest)
d = p.renderHTTP(ctx)
def rendered(ign):
p.action_close(None)
return req
d.addCallback(rendered)
return d
class Benchmark(athena.LivePage):
docFactory = loaders.stan(
tags.html[tags.head(render=tags.directive('liveglue')),
tags.body(render=tags.directive('body'))])
def __init__(self, maxNodes, maxDepth):
self.maxNodes = maxNodes
self.maxDepth = maxDepth
super(Benchmark, self).__init__()
here = filepath.FilePath(__file__).parent().child('benchmark.js')
self.jsModules.mapping.update({'Nevow.Benchmarks': here.path})
def render_body(self, ctx, data):
for j in range(self.maxNodes // self.maxDepth):
top = t = tags.div()
for i in range(self.maxDepth):
m = tags.div()
t[m]
t = m
t[InitializationBenchmark(self)]
yield top
def test_rendering(self):
"""
Test that L{webadmin.UserInteractionFragment} renders without raising
any exceptions.
"""
f = UserInteractionFragment(self.browser)
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
class MonitorPage(athena.LivePage):
addSlash = True
docFactory = loaders.stan(
tags.html[tags.head(render=tags.directive('liveglue'))[
tags.title["IPython Monitor"],
tags.link(rel="stylesheet", type="text/css", href="main.css"),
tags.link(rel="stylesheet", type="text/css", href="monitor.css")],
tags.body[tags.h1["IPython Monitor"],
tags.div(render=tags.directive('widgets'))]])
def __init__(self, controller):
athena.LivePage.__init__(self)
self.controller = controller
if not self.children:
self.children = {}
self.children["main.css"] = static.File(
util.sibpath(__file__, 'main.css'))
self.children["monitor.css"] = static.File(
util.sibpath(__file__, 'monitor.css'))
def render_widgets(self, ctx, data):
f = aw.CommandWidget(self.controller)
f.setFragmentParent(self)
g = aw.StatusWidget(self.controller)
g.setFragmentParent(self)
h = aw.ResultWidget()
h.setFragmentParent(self)
n1 = results.notifierFromFunction(h.handleResult)
self.controller.addNotifier(n1)
n2 = results.notifierFromFunction(g.refreshStatus)
f.addNotifier(n2)
reactor.callLater(1, g.refreshStatus)
build = tags.table(id="monitor")[tags.tr[tags.td(valign="top")[g],
tags.td(valign="top")[h,
tags.br,
f]]]
return ctx.tag[build]
def _render(self, element):
"""
Put the given L{IRenderer} provider into an L{athena.LivePage} and
render it. Return a Deferred which fires with the request object used
which is an instance of L{nevow.testutil.FakeRequest}.
"""
p = LivePage(
docFactory=stan(
html[
head(render=directive('liveglue')),
body[
invisible(render=lambda ctx, data: element)]]))
element.setFragmentParent(p)
ctx = WovenContext()
req = FakeRequest()
ctx.remember(req, IRequest)
d = p.renderHTTP(ctx)
def rendered(ign):
p.action_close(None)
return req
d.addCallback(rendered)
return d
class CommandPage(athena.LivePage):
addSlash = True
docFactory = loaders.stan(
tags.html[tags.head(render=tags.directive('liveglue'))[
tags.title["IPython Command"],
tags.link(rel="stylesheet", type="text/css", href="main.css"),
tags.link(rel="stylesheet", type="text/css", href="command.css")],
tags.body[tags.h1["IPython Command"],
tags.div(render=tags.directive('widget'))]])
def __init__(self, controller):
athena.LivePage.__init__(self)
self.controller = controller
if not self.children:
self.children = {}
self.children["main.css"] = static.File(
util.sibpath(__file__, 'main.css'))
self.children["command.css"] = static.File(
util.sibpath(__file__, 'command.css'))
def render_widget(self, ctx, data):
w = aw.CommandWidget(self.controller)
w.setFragmentParent(self)
return ctx.tag[w]
try:
# Check whether it is valid to be loaded
xml = """<!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<div xmlns:n="http://nevow.com/ns/nevow/0.1" >""" + restValue + '</div>'
test = loaders.xmlstr(xml, ignoreDocType=True).load()
except Exception, e:
restValue = "HTML Validation Error: please check any raw HTML blocks."
stan = T.html()[
T.head()[
T.style(type="text/css")["""
.system-message {border: 1px solid red; background-color: #FFFFDD; margin: 5px; padding: 5px;}
.system-message-title { font-weight: bold;}
"""
]
],
T.body()[
T.div()[
T.xml(restValue)
]
],
]
self.docFactory = loaders.stan(stan)
return self
def _html_fragment(self, input_string, writer=None, writer_name=None):
