sekizai.helpers: 88 total statements, 0.0% covered

Generated: Wed 2013-03-13 10:33 CET

Source file: /media/Envs/Envs/filer-gallery/lib/python2.7/site-packages/sekizai/helpers.py

Stats: 0 executed, 83 missed, 5 excluded, 48 ignored

1. # -*- coding: utf-8 -*-
2. from django.conf import settings
3. from django.template import VariableNode, Variable
4. from django.template.loader import get_template
5. from django.template.loader_tags import BlockNode, ExtendsNode
8. def is_variable_extend_node(node):
9. if hasattr(node, 'parent_name_expr') and node.parent_name_expr:
10. return True
11. if hasattr(node, 'parent_name') and hasattr(node.parent_name, 'filters'):
12. if node.parent_name.filters or isinstance(node.parent_name.var, Variable):
13. return True
14. return False
16. def _extend_blocks(extend_node, blocks):
17. """
18. Extends the dictionary `blocks` with *new* blocks in the parent node (recursive)
19. """
20. # we don't support variable extensions
21. if is_variable_extend_node(extend_node):
22. return
23. parent = extend_node.get_parent(None)
24. # Search for new blocks
25. for node in parent.nodelist.get_nodes_by_type(BlockNode):
26. if not node.name in blocks:
27. blocks[node.name] = node
28. else:
29. # set this node as the super node (for {{ block.super }})
30. block = blocks[node.name]
31. seen_supers = []
32. while hasattr(block.super, 'nodelist') and block.super not in seen_supers:
33. seen_supers.append(block.super)
34. block = block.super
35. block.super = node
36. # search for further ExtendsNodes
37. for node in parent.nodelist.get_nodes_by_type(ExtendsNode):
38. _extend_blocks(node, blocks)
39. break
41. def _extend_nodelist(extend_node):
42. """
43. Returns a list of namespaces found in the parent template(s) of this
44. ExtendsNode
45. """
46. # we don't support variable extensions (1.3 way)
47. if is_variable_extend_node(extend_node):
48. return []
49. blocks = extend_node.blocks
50. _extend_blocks(extend_node, blocks)
51. found = []
53. for block in blocks.values():
54. found += _scan_namespaces(block.nodelist, block, blocks.keys())
56. parent_template = extend_node.get_parent({})
57. # if this is the topmost template, check for namespaces outside of blocks
58. if not parent_template.nodelist.get_nodes_by_type(ExtendsNode):
59. found += _scan_namespaces(parent_template.nodelist, None, blocks.keys())
60. else:
61. found += _scan_namespaces(parent_template.nodelist, extend_node, blocks.keys())
62. return found
64. def _scan_namespaces(nodelist, current_block=None, ignore_blocks=None):
65. from sekizai.templatetags.sekizai_tags import RenderBlock
66. if ignore_blocks is None:
67. ignore_blocks = []
68. found = []
70. for node in nodelist:
71. # check if this is RenderBlock node
72. if isinstance(node, RenderBlock):
73. # resolve it's name against a dummy context
74. found.append(node.kwargs['name'].resolve({}))
75. found += _scan_namespaces(node.blocks['nodelist'], node)
76. # handle {% extends ... %} tags if check_inheritance is True
77. elif isinstance(node, ExtendsNode):
78. found += _extend_nodelist(node)
79. # in block nodes we have to scan for super blocks
80. elif isinstance(node, VariableNode) and current_block:
81. if node.filter_expression.token == 'block.super':
82. if hasattr(current_block.super, 'nodelist'):
83. found += _scan_namespaces(current_block.super.nodelist, current_block.super)
84. return found
86. def get_namespaces(template):
87. compiled_template = get_template(template)
88. return _scan_namespaces(compiled_template.nodelist)
90. def validate_template(template, namespaces):
91. """
92. Validates that a template (or it's parents if check_inheritance is True)
93. contain all given namespaces
94. """
95. if getattr(settings, 'SEKIZAI_IGNORE_VALIDATION', False):
96. return True
97. found = get_namespaces(template)
98. for namespace in namespaces:
99. if namespace not in found:
100. return False
101. return True
103. def get_varname():
104. return getattr(settings, 'SEKIZAI_VARNAME', 'SEKIZAI_CONTENT_HOLDER')
107. class Watcher(object):
108. """
109. Watches a context for changes to the sekizai data, so it can be replayed later.
110. This is useful for caching.
112. NOTE: This class assumes you ONLY ADD, NEVER REMOVE data from the context!
113. """
114. def __init__(self, context):
115. self.context = context
116. self.frozen = dict((key, list(value)) for key, value in self.data.items())
118. @property
119. def data(self):
120. return self.context.get(get_varname(), {})
122. def get_changes(self):
123. sfrozen = set(self.frozen)
124. sdata = set(self.data)
125. new_keys = sfrozen ^ sdata
126. changes = {}
127. for key in new_keys:
128. changes[key] = list(self.data[key])
129. shared_keys = sfrozen & sdata
130. for key in shared_keys:
131. old_set = set(self.frozen[key])
132. new_values = [item for item in self.data[key] if item not in old_set]
133. changes[key] = new_values
134. return changes