def _stream(self):
if self.rendered:
raise StopIteration()
self.rendered = True
data = []
for k,v in self._attributes:
v = Variable.cssvalue(v)
if v is not None:
data.append(' {0}: {1};'.format(k,v))
if data:
# yield the element
if self.comment:
yield '/*---------------------------------------------------'
yield self.comment
yield '---------------------------------------------------*/'
yield self.tag + ' {'
for s in data:
yield s
yield '}\n'
# yield mixins and children
for child_list in itervalues(self._children):
child = child_list[0]
for c in child_list[1:]:
child.extend(c)
for s in child._stream():
yield s
def __init__(self, views, site = None):
self.site = site
m = {}
for view in views:
route = view.route
path = route.path
if path in m:
raise ValueError('There seems to be multiple values for\
"{0}" path'.format(path))
node = Node(view)
m[node.path] = node
if not m:
raise ValueError('No views')
# order by level
nodes = sorted(itervalues(m), key = lambda x : x.level)
start = nodes.pop(0)
parent_level = start.level
self.roots = roots = [start]
for node in nodes:
if node.level == parent_level:
roots.append(node)
else:
if node.level > parent_level+1:
# we go up a level
parent_level += 1
route = node.route
while route.level > parent_level:
route,bit = route.split()
if route.path in m:
node.parent = m[route.path]
break
super(NRT,self).__init__(m)
def __init__(self, route, model=None, editavailable=None,
list_display_links=None, object_display=None,
related_field=None, url_bits_mapping=None,
routes=None, always_load_fields=None, **kwargs):
self.model = model
ResolverMixin.__init__(self, route)
RendererMixin.__init__(self, **kwargs)
if routes:
base_routes = OrderedDict(((r.name,r) for r in self.base_routes))
base_routes.update(((r.name,r) for r in routes))
self.base_routes = list(itervalues(base_routes))
else:
self.base_routes = list(self.base_routes)
if not self.pagination:
self.pagination = html.Pagination()
self.object_views = []
self.model_url_bits = ()
self.editavailable = editavailable if editavailable is not None else\
self.editavailable
self.list_display_links = list_display_links or self.list_display_links
self.related_field = related_field or self.related_field
self.always_load_fields = always_load_fields or self.always_load_fields
if self.parent_view and not self.related_field:
raise UrlException('Parent view "{0}" specified in\
application {1} without a "related_field".'.format(self.parent_view,self))
self.object_display = object_display or self.object_display
self.url_bits_mapping = self.url_bits_mapping or url_bits_mapping
self.clear()
def _all_ordered_choices(self, bfield, selected):
options = OrderedDict(((opt.attr('value'), opt) for opt in\
self._all_choices(bfield, selected)))
for value in selected:
opt = options.pop(value, None)
if opt is not None:
yield opt
for opt in itervalues(options):
yield opt
def __init__(self, tree, pages = None):
# create the tree for flat pages
self.tree_pages = tree_pages = {}
if pages:
flat_pages_trees = {}
for page in pages:
node = tree.get(page.url)
if node:
tree_pages[node.path] = page
else:
flat_pages_trees[page.url] = page
if flat_pages_trees:
flat_pages_trees = NRT(itervalues(flat_pages_trees))
super(DjpcmsTree,self).__init__(flat_pages_trees, tree)
else:
super(DjpcmsTree,self).__init__(tree)
else:
super(DjpcmsTree,self).__init__(tree)
def get_declared_application_routes(bases, attrs):
"""Create a list of Application views instances from the passed
in 'attrs', plus any similar fields on the base classes (in 'bases')."""
inherit = attrs.pop('inherit', True)
pviews = {}
if inherit:
for base in reversed(bases):
if hasattr(base, 'base_routes') and base.base_routes:
pviews.update(((r.name, r) for r in base.base_routes))
for app_name, obj in list(attrs.items()):
if hasattr(obj, '__class__'):
if isinstance(obj, RouteMixin):
r = attrs.pop(app_name)
r.name = app_name
if r.name in pviews:
# pick up the same order number
r.route_ordering = pviews[r.name].route_ordering
pviews[r.name] = r
return list(sorted(itervalues(pviews), key= lambda x: x.route_ordering))
def _addroutes(self):
# Clone base_routes
routes = []
for route in self.base_routes:
if not isinstance(route, RendererMixin):
raise UrlException('Route "{0}" is not a view instance. '\
'Error in constructing application "{2}".'.format(route,self))
route = deepcopy(route)
route.code = self.name + SPLITTER + route.name
routes.append(route)
#and now set the routes
processed = self.views
while routes:
N = len(routes)
for idx, route in enumerate(routes):
if route.parent_view:
if route.parent_view in processed:
p = processed[route.parent_view]
try:
route.rel_route = p.rel_route + route.rel_route
except Exception as e:
raise UrlException('Error while constructing '\
'application {0}. {1}'.format(self,e))
else:
continue
processed[route.name] = route
routes.pop(idx)
break
if len(routes) == N:
raise UrlException('Cannot find parent views in "{0}"'\
.format(self.__repr__()))
# Add routes sorted by creation counter
for route in sorted(itervalues(processed),
key=lambda x: x.route_ordering):
if route.path == '/':
self.root_view = route
if isinstance(route, View) and route.object_view:
self.object_views.append(route)
self.routes.append(route)
def nodes(self):
return itervalues(self)
def allchildren(self):
return itervalues(self.children)
def extend(self, elem):
'''Extend by adding *elem* attributes and children.'''
self._attributes.extend(elem._attributes)
for child_list in itervalues(elem._children):
for child in tuple(child_list):
child._set_parent(self)
def css_children(self):
'''Generator of all direct :class:`css` children'''
for cl in itervalues(self._children):
if isinstance(cl, list):
for c in cl:
yield c
