"""
STAN -- Stan Template Acceleration Nexus
"""
from __future__ import generators
import types
from twisted.web import html
from types import StringTypes
from twisted.web.woven import interfaces, model
from twisted.python import components, failure
from twisted.python.components import implements
from twisted.internet import reactor, defer
from cStringIO import StringIO
import sys
def keyGenerator():
x = 0
while 1:
x += 1
yield x
generateKey = keyGenerator().next
def simplify(seq, newline='\n', indent=' ', indentlevel = 0):
lst = []
strjoin = ''.join
if indentlevel != 0:
yield '\n' + (indent * indentlevel)
for x in seq:
if isinstance(x, IndentPush):
indentlevel += 1
lst.append(newline + (indent * indentlevel))
elif isinstance(x , IndentPop):
indentlevel -= 1
lst.append(newline + (indent * indentlevel))
if isinstance(x, StringTypes):
if x and x[0] == '<':
if (lst and lst[-1].find('\n') == -1):
lst.append(newline + (indent * indentlevel))
lst.append(x)
else:
if lst:
yield strjoin(lst)
del lst[:]
yield x
if lst:
yield strjoin(lst)
class IStanInstruction(components.Interface):
"""I modify the current stan virtual machine state.
"""
def operate(request, state):
"""I mutate state in place depending on the operation
I wish to perform upon the virtual machine.
"""
pass
class IStanExpandable(components.Interface):
"""I expand to a list of stan instructions to process.
"""
def generate():
"""I return a list of stan instructions.
"""
class IStanRuntimeRenderable(components.Interface):
"""I defer the rendering of my content until runtime
when some model data is available.
"""
def render(request, model):
"""I return a dynamically generated list of stan instructions
at runtime.
I am given a request and a piece of model data which
I may want to take into consideration when expanding.
"""
pass
class XMLAbomination(object):
"""This is the magic XML tag prototype factory
You can create tag prototypes like:
x = XMLAbomination()
x.html
x('html')
x['html']
Choose your poison.
"""
def __repr__(self):
return 'XMLAbomination()'
def __call__(self, name):
assert isinstance(name, StringTypes)
return XMLAbominationTagPrototype(name)
def __getitem__(self, item):
assert isinstance(item, StringTypes)
return XMLAbominationTagPrototype(name)
def __getattr__(self, name):
if name.endswith('_') or name.startswith('__'):
raise AttributeError, name
elif name.startswith('_'):
name = name[1:]
return XMLAbominationTagPrototype(name)
class XMLAbominationTagPrototype(object):
"""This is the magic XML tag prototype
You can create pretags like:
nudebody = XMLAbomination().body
nakedbody = XMLAbominationTagPrototype('body')
clothedbody = nakedbody(bgcolor='red')
darkbody = nakedbody({'bgcolor':'black'})
greenbody = XMLAbominationTagPrototype('body', bgcolor='green')
bluebody = XMLAbominationTagPrototype('body', {'bgcolor':'blue'})
Tags are created using ['blah!'] context with something in them.
This is done implicitly by the parent if necessary.
"""
def __init__(self, name, **kwargs):
self.name = name
self.attributes = [
Attribute(k, v) for (k, v) in kwargs.items()
]
def __call__(self, *args, **kwargs):
if not kwargs and len(args) == 1:
return XMLAbominationTagPrototype(self.name, **args[0])
return XMLAbominationTagPrototype(self.name, **kwargs)
def children(self, *items):
newItems = []
for x in items:
if not (isinstance(x, XMLAbominationTagPrototype)):
if isinstance(x, types.SliceType):
x.stop.setTag(x.start)
newItems.append(x.stop)
else:
newItems.append(x)
else:
print "child", x
newItems.append(x.children())
return Tag(self.name, self.attributes, newItems)
def with(self, **kwargs):
return TagWith(self, **kwargs)
def __getitem__(self, items):
print "getitem", items
if not isinstance(items, (list, tuple)):
items = [items]
return self.children(*items)
def __repr__(self):
return '<XMLAbominationTagPrototype name=%r id=%s attributes=%r>' % (self.name, hex(id(self)), self.attributes)
class Tag(object):
__implements__ = IStanExpandable,
def __init__(self, name, attributes, items):
self.name = name
self.attributes = attributes
self.children = items
def clone(self, deep=1):
if not deep:
new = XMLAbominationTagPrototype(self.name)
new.attributes = self.attributes[:]
return Tag(self.name, self.attributes[:], self.children[:])
def getAttribute(self, name):
for attr in self.attributes:
if attr.name == name:
return attr
return None
def generate(self):
key = generateKey()
yield '<' + self.name
for attribute in self.attributes:
for chunk in attribute.generate():
yield chunk
if not self.children:
yield '/>'
return
yield '>'
yield IndentPush(key)
for child in self.children:
if components.implements(child, IStanExpandable):
for chunk in child.generate():
yield chunk
else:
yield child
yield IndentPop(key)
yield '</'
yield self.name
yield '>'
def __repr__(self):
return 'Tag(%r, %r, %r)' % (self.name, self.attributes, self.children)
class _Nothing(object):
pass
class TagWith(object):
__implements__ = IStanExpandable,
def __init__(self, tag, model=_Nothing, view=_Nothing, pattern=_Nothing):
self.tag = tag
self.model = model
self.view = view
self.pattern = pattern
def children(self, *items):
self.tag = self.tag.children(*items)
return self
def __call__(self, *args, **kwargs):
return self.tag(*args, **kwargs)
def __getitem__(self, items):
if not isinstance(items, (list, tuple)):
items = [items]
return self.children(*items)
def generate(self):
pops = []
if self.model is not _Nothing or self.view is not _Nothing:
key = generateKey()
pops.append(Popper(key))
if self.view is _Nothing:
self.view = View(key)
elif isinstance(self.view, StringTypes):
self.view = View(key)
yield Pusher(key, model=self.model, view=self.view)
yield self.tag
while pops:
yield pops.pop()
class With(TagWith):
__implements__ = IStanExpandable,
tag = ""
def __init__(self, model=_Nothing, view=_Nothing, pattern=_Nothing):
self.model = model
self.view = view
self.pattern = pattern
def setTag(self, tag):
self.tag = tag
_with = With
class Attribute(object):
__implements__ = IStanExpandable,
def __init__(self, name, value):
if name.startswith('_'):
name = name[1:]
self.name = name
self.value = value
def generate(self):
yield ' '
yield self.name
yield '="'
yield self.value
yield '"'
def __repr__(self):
return 'Attribute(%s, %r)' % (self.name, self.value)
class View(object):
__implements__ = IStanRuntimeRenderable
def __init__(self, *args):
self.collected = []
self._updaters = [self.update]
self.patterns = {}
def __call__(self, **kwargs):
self.attributes.update(kwargs)
return self
def __getitem__(self, items):
if not isinstance(items, (list, tuple)):
items = [items]
self.children.extend(items)
return self.children
def getPattern(self, pattern):
return self.patterns[pattern].clone()
def update(self, model):
"""The view is being rendered against the given model;
this method should use self.__call__ and self.__getitem__
(as though self were an XMLAbomination)
to influence how this node is going to look.
"""
pass
def render(self, request, model):
print "view generated", model, self.collected
self.children = []
self.attributes = {}
for updater in self._updaters:
updater(model)
if not callable(self.collected[0]):
new = XMLAbominationTagPrototype(self.collected[0].name, **self.attributes)[self.children]
new.attributes.extend(self.collected[0].attributes)
else:
new = self.collected[0](**self.attributes)[self.children]
for chunk in new.generate():
yield chunk
def collect(self, something):
if self.collected:
return something
print "view collecting", something
if hasattr(something, 'children'):
for child in something.children:
pattern = child.getAttribute('pattern')
if pattern is not None:
self.patterns[pattern.value] = child
print "children", something.children
self.collected.append(something)
class StanInstruction(object):
__implements__ = IStanInstruction
def operate(self, request, state):
print "operate", self
class Pusher(StanInstruction):
def __init__(self, key, model=None, view=None, controller=None):
self.key = key
self.model = model
self.view = view
self.controller = controller
def __repr__(self):
return 'Pusher(%r, %r, %r, %r)' % (self.key, self.model, self.view, self.controller)
def operate(self, request, state):
StanInstruction.operate(self, request, state)
state['views'].append(self.view)
model = state['models'][-1].getSubmodel(request, self.model)
state['models'].append(model)
state['collectors'].append(self.view.collect)
class Popper(StanInstruction):
def __init__(self, key):
self.key = key
def __repr__(self):
return 'Popper(%r)' % self.key
def operate(self, request, state):
StanInstruction.operate(self, request, state)
view = state['views'].pop()
model = state['models'].pop()
state['collectors'].pop()
if implements(view, IStanRuntimeRenderable):
return view.render(request, model.getData())
class IndentPush(StanInstruction):
def __init__(self, key):
self.key = key
def __repr__(self):
return 'IndentPush(%r)' % (self.key,)
def operate(self, request, state):
state['indentlevel'][0] = state['indentlevel'][0] + 1
class IndentPop(StanInstruction):
def __init__(self, key):
self.key = key
def __repr__(self):
return 'IndentPop(%r)' % (self.key,)
def operate(self, request, state):
state['indentlevel'][0] = state['indentlevel'][0] - 1
"""
class CondIf:
__implements__ = IStanInstruction,
def __init__(self, callable, key):
self.callable = callable
self.key = key
def __repr__(self):
return '<CondIf callable=%r key=%r>' % (self.callable, self.key)
class CondIfEnd:
__implements__ = IStanInstruction,
def __init__(self, callable, key):
self.callable = callable
self.key = key
def __repr__(self):
return '<CondIfEnd callable=%r key=%r>' % (self.callable, self.key)
class IterBegin:
__implements__ = IStanInstruction,
def __init__(self, seq, key):
self.seq = seq
self.key = key
def __repr__(self):
return '<IterBegin seq=%r key=%r>' % (self.seq, self.key)
class IterEnd:
__implements__ = IStanInstruction,
def __init__(self, seq, key):
self.seq = seq
self.key = key
def __repr__(self):
return '<IterEnd seq=%r key=%r>' % (self.seq, self.key)
"""
"""
components.registerAdapter(StanAttribute, None, IStanAttribute)
components.registerAdapter(StanAttributeStr, str, IStanAttribute)
components.registerAdapter(StanAttributeInt, int, IStanAttribute)
components.registerAdapter(StanIterableUnrenderedXML, XMLAbomination, IStanIterable)
components.registerAdapter(StanIterableXML, RenderableXMLAbomination, IStanIterable)
components.registerAdapter(StanIterableStr, str, IStanIterable)
components.registerAdapter(StanIterableForEach, ForEach, IStanIterable)
components.registerAdapter(StanIterableWithModel, WithModeler, IStanIterable)
components.registerAdapter(SomeView, model.StringModel, interfaces.IView)
"""
class Driver(object):
def __init__(self, instructions, model):
if not isinstance(instructions, types.GeneratorType):
instructions = iter(instructions)
self.instructions = instructions
self.model = components.getAdapter(
model,
interfaces.IModel,
None,
components.getAdapterClassWithInheritance)
def render(self, request):
viewstack, modelstack = [], [self.model]
instructionstack = []
instructions = self.instructions
collector = []
indentlevel = [0]
self.done = 0
state = {
'views': viewstack,
'models': modelstack,
'collectors': collector,
'indentlevel': indentlevel}
while not self.done:
try:
opcode = instructions.next()
except StopIteration:
if instructionstack:
print "popping instruction stack", instructionstack
instructions = instructionstack.pop()
continue
else:
print "done!"
self.done = 1
continue
if collector:
opcode = collector[-1](opcode)
if isinstance(opcode, StringTypes):
request.write(opcode)
elif implements(opcode, IStanInstruction):
result = opcode.operate(request, state)
if result is not None:
instructionstack.append(instructions)
instructions = simplify(result, indentlevel=indentlevel[0])
class Text(View):
def __init__(self, color="black"):
View.__init__(self)
self.color = color
def update(self, model):
self(style="color: %s" % self.color)[
str(model)
]
if __name__ == '__main__':
print ''
print ''
x = XMLAbomination()
simpleDoc = x.html[
x.head[
x.title['A simple doc']
],
x.body(style='awesome')[
x.h1['html sux'],
x.h2(_class="fred").with(model='name', view=Text(color="blue"))[
x.span(pattern="listItem")["Nothing."]
]
]
]
indent = 0
print ''
print ''
one = {
'name': 'fred',
}
condensed = list(simplify(simpleDoc.generate()))
print "condensed", condensed
driver = Driver(condensed, one)
request = StringIO()
driver.render(request)
print "one"
print request.getvalue()
print ''
print ''
two = {
'name': 'bob'
}
driver = Driver(condensed, two)
request = StringIO()
driver.render(request)
print "two"
print request.getvalue()
from twisted.web import resource
from twisted.web import server
from twisted.internet import reactor
class Tester(resource.Resource):
def getChild(self, name, request):
return self
def render(self, request):
if request.args.has_key('name'):
driver = Driver(condensed, {'name': request.args['name'][0]})
driver.render(request)
request.finish()
return server.NOT_DONE_YET
return """
<html><body>
<form action="">
<input type="text" name="name" />
<input type="submit" />
</form>
</body></html>
"""
site = server.Site(Tester())
from twisted.internet import reactor
reactor.listenTCP(8081, site)
reactor.run()