# BEGIN INCLUDE from tdi import html from tdi.tools.html import decode # This is some typcial flash embedding code. # It serves as a "layout widget", placed via overlay flash = html.from_string(""" <!-- <tdi> is used as neutral dummy element (removed due to the - flag) --> <tdi tdi:scope="-flash" tdi:overlay="<-flash"> <object tdi="object_ie" classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="" height=""> <param tdi="url" name="movie" value="" /> <param tdi="param" /> <![if !IE]><object tdi="object_other" type="application/x-shockwave-flash" data="" width="" height=""> <param tdi="param" /> <![endif]> <p tdi="alternative">You need to enable <a href="http://www.adobe.com/go/getflashplayer">Flash</a> to view this content.</p> <![if !IE]></object><![endif]></object> </tdi> """) # page template, using the flash layout widget, passing parameters template = html.from_string(""" <html> <body> <h1>some flash</h1> <tdi tdi:scope="-flash.param" tdi="-init"
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') from tdi.model_adapters import RenderAdapter from tdi import html template = html.from_string(""" <anode tdi="level1"> <node tdi="-*nested"> <xnode tdi="a"></xnode> </node> <ynode tdi="-*:nested">lalala</ynode> </anode> """.lstrip()) class Model(object): def render_a(self, node): node.content = u'hey' model = Model() template.render(model, adapter=RenderAdapter.for_prerender)
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') import re as _re from tdi import html from tdi.tools import javascript tpl = html.from_string(""" <a tdi="link" onclick="alert('__what__'); return false">Click me</a> """.lstrip()) json = javascript.LiteralJSON(u'{"name": "Andr\xe9]]>"}') class Model(object): def render_link(self, node): javascript.fill_attr(node, u'onclick', dict( what = u'Andr\xe9', )) tpl.render(Model()) tpl = html.from_string(""" <a tdi="link" onclick="alert('__what__'); return false">Click me</a> """.lstrip()) json = javascript.LiteralJSON(u'{"name": "Andr\xe9]]>"}') class Model(object): def render_link(self, node): javascript.fill_attr(node, u'onclick', dict( what = json, )) tpl.render(Model())
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') from tdi.model_adapters import RenderAdapter from tdi import html template = html.from_string(""" <anode tdi="level1" tdi:prerender="remove-node"> <node tdi="-nested"> <xnode tdi="a"> <znode tdi="b">foo</znode> </xnode> </node> <ynode tdi="-:nested">lalala</ynode> </anode> """.lstrip()) class Model(object): def render_a(self, node): node.b.content = u'hey' node.b.hiddenelement = True node.b['tdi:prerender'] = u'remove-node' model = Model() template.render(model, adapter=RenderAdapter.for_prerender)
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') from tdi import html template = html.from_string(""" <node tdi="item"> <node tdi="nested"> <node tdi="subnested"></node> </node> <xnode tdi="a"></xnode> </node> """.lstrip()) class Model(object): def render_item(self, node): node.nested.replace(self.replace_nested, node.a) return True def replace_nested(self, node): node['been'] = u'here' node.content = u'yes' def render_a(self, node): node.content = u"should not be here" model = Model() template.render(model)
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') from tdi import html template = html.from_string(""" <node tdi="item"> <node tdi="nested"> <node tdi="subnested"></node> </node><tdi tdi=":-nested"> </tdi> </node> """.lstrip()) class Model(object): def render_item(self, node): for subnode, item in node.nested.iterate([1, 2, 3, 4]): subnode['j'] = item subnode.content = u'should be here %s' % item if item == 3: break model = Model() template.render(model)
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') from tdi import html from tdi.model_adapters import PreRenderWrapper, RenderAdapter template = html.from_string(""" <foo> <bar tdi:overlay=">-foo"/> </foo> """.lstrip()).overlay(html.from_string(""" <tdi tdi:overlay="-foo"> <script tdi="test">JAVASCRIPT</script> </tdi> """.lstrip())) class Model(object): def render_test(self, node): node.raw.content = node.raw.content.replace('SCR', ' hey ') def adapter(model): return PreRenderWrapper(RenderAdapter(model)) model = Model() html.from_string(template.render_string(None, adapter=adapter)).render( model, startnode="test" ) print
""" HTML minifier factory """ return html_tools.MinifyFilter(builder, comment_filter=keep_foo) # 3. Template Factory html = html.replace(eventfilters=[ # ... html_minifyfilter, # instead of html_tools.MinifyFilter # ... ]) # 4. Do your thing. tpl = html.from_string(""" <html> <head> <!-- Here comes the title --> <title>Hello World!</title> <style> Some style. </style> </head> <body> <!-- foo --> <script> Some script. </script> <h1>Hello World!</h1> <!-- bar --> </body> """.lstrip()) tpl.render()
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') from tdi import html template = html.from_string(""" <node> <xnode tdi="zonk" tdi:scope="foo"></xnode> </node> """.lstrip()) class FooModel(object): def render_zonk(self, node): node.content = u"Yay." class Model(object): def __init__(self): self.scope_foo = FooModel() model = Model() template.render(model)
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') # BEGIN INCLUDE from tdi import html from tdi.tools import htmlform template = html.from_string(""" <html> <body> <p>Type your name:</p> <form tdi="form"> <div tdi="-name"> <p tdi="*error" class="error">Error message</p> <input tdi="*field" id="name" type="text" /> </div> <input tdi="submit" type="submit" /> </form> </body> </html> """) class Model(object): def __init__(self, errors=None): self._errors = errors or {} self._form = htmlform.HTMLForm( pre_proc=self.preproc, post_proc=htmlform.TabIndexer(), )
import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings("error") from tdi import html template = html.from_string( """ <node tdi="item"> <znode tdi="nested" tdi:overlay="foo"> <ynode tdi="subnested"></ynode> </znode> <xnode tdi="a"></xnode> </node> """.lstrip() ).overlay( html.from_string( """ <anode tdi="grumpf" tdi:overlay="-foo"> <bnode tdi="gna"></bnode> </anode> """.lstrip() ) ) class Model(object): def render_nested(self, node): node["been"] = u"here" def render_gna(self, node):
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') from tdi.model_adapters import RenderAdapter from tdi import html template = html.from_string(""" <anode tdi="level1"> <node tdi="-nested" tdi:scope="foo.bar" tdi:overlay="ov"> <xnode tdi="a" tdi:scope="baz"></xnode> </node> <ynode tdi="-:nested">lalala</ynode> </anode> """.lstrip()).overlay(html.from_string(""" <znode tdi:scope="zonk"> <widget tdi:overlay="ov">widget!</widget> </znode> """.lstrip())) template.render(None, adapter=RenderAdapter.for_prerender)
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') from tdi import html template = html.from_string(""" <anode tdi="level1"> <node tdi="*level2"> <node tdi="level3"> hey. </node> </node> </anode> """.lstrip()) class Model(object): def render_level2(self, node): node['foo'] = 'bar' def render_level3(self, node): node.content = 'sup.' model = Model() template.render(model)
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') from tdi import html from tdi.tools import javascript html = html.replace(eventfilters=[javascript.CDATAFilter]) tpl = html.from_string(""" <html> <script src="foo"></script> <script><!-- //--></script> <script><!-- var x=1; var y = 2; alert( x + y ); //--></script> <script tdi="bar"><!-- --></script> </html> """.lstrip()) tpl.render()
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') from tdi import html template = html.from_string(""" <node tdi="item"> <znode tdi:overlay="foo"> <ynode tdi:overlay="bar"></ynode> <ynode tdi:overlay="<zonk"></ynode> <ynode tdi:overlay=">plenk"></ynode> </znode> <xnode tdi:overlay=">baz"></xnode> </node> """.lstrip()) print list(sorted(template.source_overlay_names)) print list(sorted(template.target_overlay_names))
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') from tdi import html template = html.from_string(""" <node> <xnode></xnode> </node> """.lstrip()) print template print template.tree template.render()
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') from tdi import html template = html.from_string(""" <html> <body> <ul> <li tdi="menu"><a tdi="link">some menu item</a></li> </ul> </body> </html> """) class Model(object): def __init__(self, menu, page): self._menu = menu self._page = page # BEGIN INCLUDE def render_menu(self, node): node.repeat(self.repeat_menu, self._menu) def repeat_menu(self, node, (href, menuitem)): node.link.content = menuitem if (node.ctx[0] + 1 == self._page): node.link.hiddenelement = True else: node.link['href'] = href
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') import os os.chdir(os.path.dirname(os.path.abspath(os.path.normpath(__file__)))) # BEGIN INCLUDE from tdi import html from tdi import factory template = html.from_string(""" <html> <body tdi="body"> some template </body> </html> """) print template.tree template = html.from_file('loading.html') print template.tree stream = open('loading.html') try: template = html.from_stream(stream) finally: stream.close() print template.tree
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') # BEGIN INCLUDE from tdi import html content = html.from_string(""" <html> <body> <h1 tdi="doctitle">doc title goes here</h1> <ul tdi:overlay="menu"></ul> <p tdi="intro" class="edit-intro">Intro goes here.</p> <div class="list" tdi="list"> ... </div> </body> </html> """) menu_widget = html.from_string(""" <html> <body> <ul tdi:overlay="menu"> <li tdi="menu"><a tdi="link">some menu item</a></li><li tdi=":-menu"> </li> </ul> </body> </html> """) class Model(object):
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') from tdi import html template = html.from_string(""" <node tdi="item"> <znode tdi="nested" tdi:overlay="foo"> <ynode tdi="subnested"></ynode> </znode> <xnode tdi=":nested" tdi:overlay="bar"> separator </xnode> </node> """.lstrip()).overlay(html.from_string(""" <anode tdi:overlay="foo"> overlayed </anode> """.lstrip())) class Model(object): def render_nested(self, node): for subnode, item in node.iterate([0, 1]): subnode.content = item model = Model() template.render(model)
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') # BEGIN INCLUDE from tdi import html from tdi.tools import htmlform template = html.from_string(""" <html> <body> <p>Type your name:</p> <form tdi="form"> <input tdi="name" type="text" /> <input tdi="submit" type="submit" /> </form> </body> </html> """) class Model(object): def __init__(self): self._form = htmlform.HTMLForm(post_proc=htmlform.TabIndexer()) def render_form(self, node): self._form.form(node) def render_name(self, node): self._form.text(node, u"name") def render_submit(self, node):
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings("error") from tdi import html template = html.from_string( """ <?xml version="1.0" encoding="utf-8" ?> <node> <xnode tdi="foo"></xnode> </node> """.lstrip() ) class Model(object): def render_foo(self, node): try: node[u"b\xe9lah"] = u"bl\xf6d" except UnicodeError: node[u"blah"] = u"bl\xf6d" template.render(Model())
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') # BEGIN INCLUDE from tdi import html template = html.from_string(""" <html> <body> <h1 tdi="doctitle">doc title goes here</h1> <ul class="menu"> <li><a href="menu1" tdi="menu1">some menu item</a></li> <li><a href="menu2" tdi="menu2">Editing Content & Attributes</a></li> <li><a href="menu3" tdi="menu3">Other menu item</a></li> </ul> <p tdi="intro" class="edit-intro">Intro goes here.</p> <div class="list" tdi="list"> ... </div> </body> </html> """) class Model(object): def __init__(self, possibilities, page): self._possibilities = possibilities self._page = page def render_doctitle(self, node): node.content = u"Editing Content & Attributes"
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') from tdi.model_adapters import RenderAdapter from tdi import html template = html.from_string(""" <anode tdi="level1"> <node tdi="-nested" tdi:scope="foo.bar"> <xnode tdi="a" tdi:scope="baz"></xnode> </node> <ynode tdi="-:nested">lalala</ynode> </anode> """.lstrip()) template.render(None, adapter=RenderAdapter.for_prerender)
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') from tdi import html template = html.from_string(""" <node tdi="item"> <znode tdi:overlay="foo"> <ynode tdi="subnested"></ynode> </znode> </node> """.lstrip()) class Model(object): def render_subnested(self, node): node.content = u"yeah." model = Model() template.render(model, startnode="item.subnested") print
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') from tdi import html from tdi.tools import css html = html.replace(eventfilters=[ css.CDATAFilter, css.MinifyFilter, ]) tpl = html.from_string(""" <html> <style><!-- --></style> <style><!-- a b c{ foo: bar; baz: blub; } --></style> <style tdi="bar"><!-- --></style> </html> """.lstrip()) tpl.render()
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') from tdi import html template = html.from_string(""" <html> <body> <ul class="menu" tdi="menu"> <li><a href="menu1" tdi="*menu1">some menu item</a></li> <li><a href="menu2" tdi="*menu2">Editing Content & Attributes</a></li> <li><a href="menu3" tdi="*menu3">Other menu item</a></li> </ul> </body> </html> """) class Model(object): def __init__(self, page): self._page = page def render_menu(self, node): node("menu%d" % self._page).hiddenelement = True def render_menu1(self, node): node.content = "shouldn't come here..." model = Model(page=2) template.render(model)
Submitted by: Jens Michlo """ import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') from tdi import html template = html.from_string(""" <tdi tdi="-items"> <tdi tdi="-item"> <tdi tdi="-product"> Produtcs </tdi> <tdi tdi="-offer"> Offer </tdi> <tdi tdi="-leer"> leer </tdi> </tdi> </tdi> """.lstrip()) class Model(object): def _render(self, subnode, item): print "OK", item def render_items(self, node): items = [1 ,2 ,3]
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') # BEGIN INCLUDE from tdi import html from tdi.tools import javascript template = html.from_string(""" <html> <body> <tdi tdi="-script"> <div tdi="*html"><h1 tdi="h1">dynamic js-only-content</h1></div> <script tdi="*script"> document.write('__html__') </script> </tdi> </body> </html> """.lstrip()) class Model2(object): def render_h1(self, node): node.content = u"different." class Model(object): def render_h1(self, node): node.content = u"My Heading"
#!/usr/bin/env python import warnings as _warnings _warnings.resetwarnings() _warnings.filterwarnings('error') # BEGIN INCLUDE from tdi import html template = html.from_string(""" <html> <body> <p>My fruit salad contains <tdi tdi="-fruit">Apples</tdi><tdi tdi=":-fruit">, </tdi>.</p> </body> </html> """.lstrip()) class Model(object): def __init__(self, fruits): self._fruits = fruits def render_fruit(self, node): node.repeat(self.repeat_fruit, self._fruits, len(fruits) - 2) def repeat_fruit(self, node, fruit, last_sep_idx): node.content = fruit def separate_fruit(self, node, last_sep_idx): if node.ctx[0] == last_sep_idx: node.content = u' and '