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 test_nested_data(self):
def checkContext(ctx, data):
self.assertEquals(data, "inner")
self.assertEquals(ctx.locate(inevow.IData, depth=2), "outer")
return 'Hi'
tag = tags.html(data="outer")[tags.span(render=lambda ctx,data: ctx.tag, data="inner")[checkContext]]
self.assertEquals(self.render(tag), "<html><span>Hi</span></html>")
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 test_nested_data(self):
def checkContext(ctx, data):
self.assertEqual(data, "inner")
self.assertEqual(ctx.locate(inevow.IData, depth=2), "outer")
return 'Hi'
tag = tags.html(data="outer")[tags.span(render=lambda ctx,data: ctx.tag, data="inner")[checkContext]]
self.assertEqual(self.render(tag), "<html><span>Hi</span></html>")
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()
def test_precompileDoesntChangeOriginal(self):
doc = tags.html(data="foo")[tags.p['foo'], tags.p['foo']]
result = self.render(doc, precompile=True)
rendered = self.render(result)
self.assertEquals(len(doc.children), 2)
self.assertEquals(rendered, "<html><p>foo</p><p>foo</p></html>")
def test_precompileDoesntChangeOriginal(self):
doc = tags.html(data="foo")[tags.p['foo'], tags.p['foo']]
result = self.render(doc, precompile=True)
rendered = self.render(result)
self.assertEqual(len(doc.children), 2)
self.assertEqual(rendered, "<html><p>foo</p><p>foo</p></html>")
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)]))
class Root(rend.Page):
implements(ITodo)
child_css = webform.defaultCSS
docFactory = loaders.stan(
t.html(render=t.directive("time"))[
t.head[
t.title['todo'],
t.style(type="text/css")[".done { color: #dddddd; }"],
t.style(type="text/css")["@import url(/css);"]
],
t.body[
webform.renderForms(),
t.ul(data=t.directive("findAll"),
render=t.directive("sequence"))[
t.li(pattern="item",render=t.directive('todo')),
t.li(pattern="empty",render=t.directive('empty')),
],
t.p(render=t.directive("end"))
]
]
)
def insert(self, ctx, description):
return itodo.ITodos(ctx).add(description, 0)
def delete(self, ctx, id):
return itodo.ITodos(ctx).delete(id)
def update(self, ctx, id, oldstate):
newstate = [1, 0][oldstate]
return itodo.ITodos(ctx).update(id, newstate)
def data_findAll(self, ctx, data):
return itodo.ITodos(ctx).findAll()
def render_todo(self, ctx, data):
deluri = "freeform_post!!delete?id="+str(data[0])
updateuri = "freeform_post!!update?id="+str(data[0])+"&oldstate="+str(data[2])
state = [" Done", " To Do"][int(data[2])==0]
tag = ctx.tag
if data[2]:
tag = ctx.tag(_class="done")
return tag[data[1]+" - ",
t.a(href=deluri)["Delete"], " / ",
t.a(href=updateuri)[("Mark Done", "Mark Undone")[data[2]]],
state]
def render_empty(self, ctx, data):
return ctx.tag["No Todos"]
def render_time(self, ctx, data):
ctx.remember(now(), itodo.ITimer)
return ctx.tag
def render_end(self, ctx, data):
return ctx.tag["%.3f"%(now()-itodo.ITimer(ctx))]
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 setUp(self):
self.d = Deferred()
self.d2 = Deferred()
self.r = rend.Page(
docFactory=loaders.stan(
tags.html(data=self)[
'Hello ', tags.invisible[tags.invisible[tags.invisible[tags.invisible[deferit]]]],
deferdot,
]
)
)
def test_nested_remember(self):
class IFoo(compy.Interface):
pass
class Foo(str):
__implements__ = IFoo
def checkContext(ctx, data):
self.assertEquals(ctx.locate(IFoo), Foo("inner"))
self.assertEquals(ctx.locate(IFoo, depth=2), Foo("outer"))
return 'Hi'
tag = tags.html(remember=Foo("outer"))[tags.span(render=lambda ctx,data: ctx.tag, remember=Foo("inner"))[checkContext]]
self.assertEquals(self.render(tag), "<html><span>Hi</span></html>")
def test_nested_remember(self):
class IFoo(Interface):
pass
class Foo(str):
implements(IFoo)
def checkContext(ctx, data):
self.assertEquals(ctx.locate(IFoo), Foo("inner"))
self.assertEquals(ctx.locate(IFoo, depth=2), Foo("outer"))
return 'Hi'
tag = tags.html(remember=Foo("outer"))[tags.span(render=lambda ctx,data: ctx.tag, remember=Foo("inner"))[checkContext]]
self.assertEquals(self.render(tag), "<html><span>Hi</span></html>")
class Page(rend.Page):
docFactory = loaders.stan(
html(render=directive("template"))[body[
p(render=directive("before")), p[slot(name="maincontent")],
p(render=directive("after")), ], ])
def render_before(self, context, data):
return context.tag["before"]
def render_template(self, context, data):
context.fillSlots('maincontent', Fragment())
return context.tag
def render_after(self, context, data):
return context.tag["after"]
def test_it(self):
class Cool(object):
def __init__(self):
self.counter = 0
def count(self, context, data):
self.counter += 1
return self.counter
it = Cool()
tag = tags.html(data={'counter': it.count})[
tags.invisible(data=tags.directive('counter'))[
str
]
]
precompiled = self.render(tag, precompile=True)
val = self.render(precompiled)
self.assertSubstring('1', val)
val2 = self.render(precompiled)
self.assertSubstring('2', val2)
def test_it(self):
class Cool(object):
def __init__(self):
self.counter = 0
def count(self, context, data):
self.counter += 1
return self.counter
it = Cool()
tag = tags.html(data={'counter': it.count})[tags.invisible(
data=tags.directive('counter'))[str]]
precompiled = self.render(tag, precompile=True)
val = self.render(precompiled)
self.assertSubstring('1', val)
val2 = self.render(precompiled)
self.assertSubstring('2', val2)
def test_cloning(self):
def data_foo(context, data): return [{'foo':'one'}, {'foo':'two'}]
def render_test(context, data):
return tags.ul(render=rend.sequence)[
tags.li(pattern='item')[
'foo', (((tags.invisible(data=tags.directive('foo'), render=str),),),)
]
]
document = tags.html(data=data_foo)[
tags.body[
tags.ul(render=rend.sequence)[
tags.li(pattern='item')[
tags.a(href=('test/', tags.invisible(data=tags.directive('foo'), render=str)))['link']
]
],
render_test
]
]
document=self.render(document, precompile=True)
self.assertEquals(self.render(document), '<html><body><ul><li><a href="test/one">link</a></li><li><a href="test/two">link</a></li></ul><ul><li>fooone</li><li>footwo</li></ul></body></html>')
def mapHtml():
width = 600
height = 900
dots = []
for measurement in UpdatingMeasurements().measurements:
try:
speed = float(measurement['speed'])
except ValueError:
print "no speed", measurement
continue
color = "#%02x%02x%02x" % (interp(speed, 50, 0, 0, 255),
interp(speed, 40, 80, 0, 255),
0)
pos = (interp(float(measurement['longitude']), -122.72, -121.50, 0, width),
interp(float(measurement['latitude']), 38.41, 36.93, 0, height))
dotText = u'\u2739'
if random.random() > .9:
dotText += ' %d' % speed
dots.append(
T.div(style="color: %s; position: absolute; left: %spx; top: %spx" %
(color, pos[0], pos[1]))[dotText])
page = [T.raw('''<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">'''),
T.html(xmlns="http://www.w3.org/1999/xhtml")[
T.head[T.style[T.raw('''
* {
font-size: 90%;
}
''')]],
T.body[
T.div(style="width: %spx; height: %spx" % (width, height))[
dots
]]]]
return flat.flatten(page)
def test_cloning(self):
def data_foo(context, data):
return [{'foo': 'one'}, {'foo': 'two'}]
# tests nested lists without precompilation (precompilation flattens the lists)
def render_test(context, data):
return tags.ul(render=rend.sequence)[tags.li(
pattern='item')['foo', (((
tags.invisible(data=tags.directive('foo'), render=str), ),
), )]]
# tests tags inside attributes (weird but useful)
document = tags.html(data=data_foo)[tags.body[tags.ul(
render=rend.sequence)[tags.li(pattern='item')[tags.a(
href=('test/',
tags.invisible(data=tags.directive('foo'), render=str)
))['link']]], render_test]]
document = self.render(document, precompile=True)
self.assertEquals(
self.render(document),
'<html><body><ul><li><a href="test/one">link</a></li><li><a href="test/two">link</a></li></ul><ul><li>fooone</li><li>footwo</li></ul></body></html>'
)
def mapHtml():
width = 600
height = 900
dots = []
for measurement in UpdatingMeasurements().measurements:
try:
speed = float(measurement['speed'])
except ValueError:
print "no speed", measurement
continue
color = "#%02x%02x%02x" % (interp(
speed, 50, 0, 0, 255), interp(speed, 40, 80, 0, 255), 0)
pos = (interp(float(measurement['longitude']), -122.72, -121.50, 0,
width),
interp(float(measurement['latitude']), 38.41, 36.93, 0, height))
dotText = u'\u2739'
if random.random() > .9:
dotText += ' %d' % speed
dots.append(
T.div(
style="color: %s; position: absolute; left: %spx; top: %spx" %
(color, pos[0], pos[1]))[dotText])
page = [
T.raw('''<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">'''),
T.html(xmlns="http://www.w3.org/1999/xhtml")[T.head[T.style[T.raw('''
* {
font-size: 90%;
}
''')]], T.body[T.div(style="width: %spx; height: %spx" %
(width, height))[dots]]]
]
return flat.flatten(page)
def test_cloning(self):
def data_foo(context, data): return [{'foo':'one'}, {'foo':'two'}]
# tests nested lists without precompilation (precompilation flattens the lists)
def render_test(context, data):
return tags.ul(render=rend.sequence)[
tags.li(pattern='item')[
'foo', (((tags.invisible(data=tags.directive('foo'), render=str),),),)
]
]
# tests tags inside attributes (weird but useful)
document = tags.html(data=data_foo)[
tags.body[
tags.ul(render=rend.sequence)[
tags.li(pattern='item')[
tags.a(href=('test/', tags.invisible(data=tags.directive('foo'), render=str)))['link']
]
],
render_test
]
]
document=self.render(document, precompile=True)
self.assertEqual(self.render(document), '<html><body><ul><li><a href="test/one">link</a></li><li><a href="test/two">link</a></li></ul><ul><li>fooone</li><li>footwo</li></ul></body></html>')
def test_slot(self):
val = self.render(tags.html().fillSlots(
'bar', None)(foo=tags.slot('bar'))["Bar"])
self.assertEqual(val, "<html>Bar</html>")
def test_nestedTags(self):
self.assertEquals(
ten.flatten(
tags.html(hi='there')[
tags.body[ 42 ]]),
'<html hi="there"><body>42</body></html>')
def test_slot(self):
val = self.render(tags.html().fillSlots('bar', None)(foo=tags.slot('bar'))["Bar"])
self.assertEquals(val, "<html>Bar</html>")
def setupContext(self, *args, **kw):
ctx = test_flatstan.Base.setupContext(self, *args, **kw)
return context.PageContext(tag=tags.html(), parent=ctx)
class OnePatternTestCase(testutil.TestCase):
"""
Test various C{IQ.onePattern} implementations.
"""
_patternDiv = tags.div(pattern="foo")
_simpleStan = tags.html[_patternDiv]
_simpleSlot = tags.slot('slotname')[_patternDiv]
_tooManyPatternsSiblingStan = tags.html[tags.div(pattern="foo"),
tags.div(pattern="foo")]
_manyPatternsLinealStan = tags.html(pattern="foo")[tags.div(pattern="foo"),
"extra content"]
def _testQuery(self, container, expected):
pattern = IQ(container).onePattern('foo')
# The pattern node has had its pattern special removed - put it back,
# so we can perform a comparison
self.assertEqual(pattern.pattern, None)
pattern.pattern = 'foo'
self.assertEqual(str(pattern), str(expected))
def test_tagQuery(self):
return self._testQuery(self._simpleStan, self._patternDiv)
def test_contextQuery(self):
return self._testQuery(context.WovenContext(tag=self._simpleStan),
self._patternDiv)
def test_listQuery(self):
return self._testQuery(flat.precompile(self._simpleStan),
self._patternDiv)
def test_loaderQuery(self):
return self._testQuery(loaders.stan(self._simpleStan),
self._patternDiv)
def test_slotQuery(self):
return self._testQuery(self._simpleSlot, self._patternDiv)
def test_precompiledSlotQuery(self):
return self._testQuery(flat.precompile(self._simpleSlot),
self._patternDiv)
def _testTooManyPatterns(self, obj):
"""
Test that the L{IQ} adapter for C{obj} provides a L{onePattern} method
which raises L{stan.TooManyNodes} if passed a pattern name for which
there are multiple pattern nodes.
"""
self.assertRaises(stan.TooManyNodes, IQ(obj).onePattern, 'foo')
def test_stanTooManySiblingPatterns(self):
"""
Test that a Tag with children with the same pattern name causes
onePattern to raise L{TooManyNodes}.
"""
return self._testTooManyPatterns(self._tooManyPatternsSiblingStan)
def test_contextTooManySiblingPatterns(self):
"""
Like L{test_stanTooManySiblingPatterns} but for a WovenContext.
"""
return self._testTooManyPatterns(
context.WovenContext(tag=self._tooManyPatternsSiblingStan))
def test_listTooManySiblingPatterns(self):
"""
Like L{test_stanTooManySiblingPatterns} but for a list.
"""
return self._testTooManyPatterns([self._tooManyPatternsSiblingStan])
def test_precompiledTooManySiblingPatterns(self):
"""
Like L{test_stanTooManySiblingPatterns} but for a precompiled document.
"""
P = flat.precompile(self._tooManyPatternsSiblingStan)
return self._testTooManyPatterns(P)
def test_loaderTooManySiblingPatterns(self):
"""
Like L{test_stanTooManySiblingPatterns} but for a loader.
"""
return self._testTooManyPatterns(
loaders.stan(self._tooManyPatternsSiblingStan))
def test_stanMultipleLinealPatterns(self):
"""
Test that calling onePattern a Tag with a pattern and a child with the
same pattern
"""
return self._testQuery(self._manyPatternsLinealStan,
self._manyPatternsLinealStan)
def test_contextMultipleLinealPatterns(self):
return self._testQuery(
context.WovenContext(tag=self._manyPatternsLinealStan),
self._manyPatternsLinealStan)
def test_listMultipleLinealPatterns(self):
return self._testQuery([self._manyPatternsLinealStan],
self._manyPatternsLinealStan)
def test_precompiledMultipleLinealPatterns(self):
P = flat.precompile(self._manyPatternsLinealStan)
return self._testQuery(P, P[0].tag)
def test_loaderMultipleLinealPatterns(self):
return self._testQuery(
loaders.stan(self._manyPatternsLinealStan),
loaders.stan(self._manyPatternsLinealStan).load()[0].tag)
def test_tagNotEnough(self):
self.assertRaises(stan.NodeNotFound, IQ(notEnough).onePattern, 'foo')
def test_contextNotEnough(self):
self.assertRaises(stan.NodeNotFound,
IQ(context.WovenContext(tag=notEnough)).onePattern,
'foo')
def test_contextTagQuery(self):
T = simple.clone(deep=False)
T.pattern = "outer"
C = context.WovenContext(tag=T)
new = IQ(C).onePattern('outer')
self.assertEquals(new.tagName, 'html')
def test_listNotEnough(self):
P = flat.precompile(notEnough)
self.assertRaises(stan.NodeNotFound, IQ(P).onePattern, 'foo')
def test_loaderNotEnough(self):
L = loaders.stan(notEnough)
self.assertRaises(stan.NodeNotFound, IQ(L).onePattern, 'foo')
import warnings
from zope.interface import implements
from twisted.python import components
from nevow.util import Deferred, DeferredList, getPOSTCharset
from nevow import inevow, tags
from nevow.context import WovenContext
import formless
from formless.formutils import enumerate
from formless import iformless
faketag = tags.html()
def exceptblock(f, handler, exception, *a, **kw):
try:
result = f(*a, **kw)
except exception, e:
return handler(e)
if isinstance(result, Deferred):
def _(fail):
fail.trap(exception)
return handler(fail.value)
return result.addErrback(_)
else:
return result
def test_deepSlot(self):
val = self.render(tags.html().fillSlots('bar', lambda c,d: None)(foo=tags.slot('bar'))["Bar"])
self.assertEqual(val, "<html>Bar</html>")
def test_nested(self):
val = self.render(tags.html(src=entities.quot)[entities.amp])
self.assertEqual(val, '<html src=""">&</html>')
class Main(rend.Page):
docFactory = loaders.stan([
T.raw('''<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">'''),
T.html(xmlns="http://www.w3.org/1999/xhtml")[T.head[T.style[T.raw('''
* { font-family: sans-serif; }
table {
border-collapse: collapse;
}
table, td, th {
border: 1px solid gray;
padding: 3px;
}
.timing {
margin-top: 1em;
border: 1px solid #ccc;
width: 30em;
}
.timing table, .timing td {
border: 0;
}
.credit {
margin-top: 1em;
border: 1px solid #ccc;
padding: .3em;
background: #eee;
}
.dir-N { background: #cfc; }
.dir-S { background: #fcf; }
''')]], T.body[
#T.directive('table'),
T.directive('hist'),
T.directive('timing'),
T.div(class_="credit")[T.a(href="http://pems.dot.ca.gov/"
)["Data from PeMS, Caltrans"]], ]]
])
def renderHTTP(self, ctx):
req = inevow.IRequest(ctx)
req.setHeader('Content-type', 'application/xhtml+xml')
return rend.Page.renderHTTP(self, ctx)
def render_table(self, ctx, data):
import segment_report
reload(segment_report)
return segment_report.table(latestMeas)
def render_timing(self, ctx, data):
return T.div(class_="timing")[T.table[
T.tr[T.td["Data timestamp says "],
T.td[datetime.datetime.fromtimestamp(latestMeas.lastDataTime).
isoformat()]],
T.tr[T.td["Last fetched at "],
T.td[datetime.datetime.fromtimestamp(latestMeas.lastFtpTime).
isoformat()]],
T.tr[T.td["Page generated at "],
T.td[datetime.datetime.fromtimestamp(int(time.time())).
isoformat()]], ]]
def render_hist(self, ctx, data):
import route_history_report
reload(route_history_report)
D = route_history_report.Diagram
shadows = True
if ctx.arg('shadow') == 'off':
shadows = False
return [
T.div[T.h2['Southbound'],
D(shadows=shadows, freewayDir='S').render()],
T.div[T.h2['Northbound'],
D(shadows=shadows, freewayDir='N').render()],
T.div[T.a(href="?shadow=off")["(turn off shadows)"]]
]
class Page(rend.Page):
docFactory = loaders.stan(html(render=directive("notfound dummy")))
class MisdefinedPage(rend.Page):
docFactory = loaders.stan(html(render=directive(rendererName)))
def setupContext(self, *args, **kw):
ctx = test_flatstan.Base.setupContext(self, *args, **kw)
return context.PageContext(tag=tags.html(), parent=ctx)
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):
return restsupport.htmlFragment(input_string, writer=writer, writer_name=writer_name)
def test_simple(self):
val = self.render(tags.html(foo=None)["Bar"])
self.assertEqual(val, "<html>Bar</html>")
def test_deepSlot(self):
val = self.render(tags.html().fillSlots('bar', lambda c,d: None)(foo=tags.slot('bar'))["Bar"])
self.assertEquals(val, "<html>Bar</html>")
def test_deferredSlot(self):
self.render(tags.html().fillSlots('bar', defer.succeed(None))(foo=tags.slot('bar'))["Bar"],
wantDeferred=True).addCallback(
lambda val: self.assertEqual(val, "<html>Bar</html>"))
def test_deferredSlot(self):
self.render(tags.html().fillSlots('bar', defer.succeed(None))(foo=tags.slot('bar'))["Bar"],
wantDeferred=True).addCallback(
lambda val: self.assertEquals(val, "<html>Bar</html>"))
def test_simple(self):
val = self.render(tags.html(foo=None)["Bar"])
self.assertEquals(val, "<html>Bar</html>")
def test_contextTagTooMany(self):
tooMany = tags.html(pattern="foo")[ tags.div(pattern="foo") ]
self.assertRaises(stan.TooManyNodes, IQ(context.WovenContext(tag=tooMany)).onePattern, 'foo')
def test_contextTagTooMany(self):
tooMany = tags.html(pattern="foo")[tags.div(pattern="foo")]
self.assertRaises(stan.TooManyNodes,
IQ(context.WovenContext(tag=tooMany)).onePattern,
'foo')
def test_nested(self):
val = self.render(tags.html(src=entities.quot)[entities.amp])
self.assertEquals(val, '<html src=""">&</html>')
