sekizai.templatetags.sekizai_tags: 80 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/templatetags/sekizai_tags.py

Stats: 0 executed, 72 missed, 8 excluded, 62 ignored

  1. from classytags.arguments import Argument, Flag
  2. from classytags.core import Tag, Options
  3. from classytags.parser import Parser
  4. from django import template
  5. from django.conf import settings
  6. from django.utils.importlib import import_module
  7. from sekizai.helpers import get_varname
  8. register = template.Library()
  9. def validate_context(context):
  10. """
  11. Validates a given context.
  12. Returns True if the context is valid.
  13. Returns False if the context is invalid but the error should be silently
  14. ignored.
  15. Raises a TemplateSyntaxError if the context is invalid and we're in debug
  16. mode.
  17. """
  18. if get_varname() in context:
  19. return True
  20. if not settings.TEMPLATE_DEBUG:
  21. return False
  22. raise template.TemplateSyntaxError(
  23. "You must enable the 'sekizai.context_processors.sekizai' template "
  24. "context processor or use 'sekizai.context.SekizaiContext' to "
  25. "render your templates."
  26. )
  27. def import_processor(import_path):
  28. if '.' not in import_path:
  29. raise TypeError("Import paths must contain at least one '.'")
  30. module_name, object_name = import_path.rsplit('.', 1)
  31. module = import_module(module_name)
  32. return getattr(module, object_name)
  33. class SekizaiParser(Parser):
  34. def parse_blocks(self):
  35. super(SekizaiParser, self).parse_blocks()
  36. self.blocks['nodelist'] = self.parser.parse()
  37. class AddtoblockParser(Parser):
  38. def parse_blocks(self):
  39. name = self.kwargs['name'].var.token
  40. self.blocks['nodelist'] = self.parser.parse(
  41. ('endaddtoblock', 'endaddtoblock %s' % name)
  42. )
  43. self.parser.delete_first_token()
  44. class SekizaiTag(Tag):
  45. def render(self, context):
  46. if validate_context(context):
  47. return super(SekizaiTag, self).render(context)
  48. return ''
  49. class RenderBlock(Tag):
  50. name = 'render_block'
  51. options = Options(
  52. Argument('name'),
  53. 'postprocessor',
  54. Argument('postprocessor', required=False, default=None, resolve=False),
  55. parser_class=SekizaiParser,
  56. )
  57. def render_tag(self, context, name, postprocessor, nodelist):
  58. if not validate_context(context):
  59. return nodelist.render(context)
  60. rendered_contents = nodelist.render(context)
  61. varname = get_varname()
  62. data = context[varname][name].render()
  63. if postprocessor:
  64. func = import_processor(postprocessor)
  65. data = func(context, data, name)
  66. return '%s\n%s' % (data, rendered_contents)
  67. register.tag(RenderBlock)
  68. class AddData(SekizaiTag):
  69. name = 'add_data'
  70. options = Options(
  71. Argument('key'),
  72. Argument('value'),
  73. )
  74. def render_tag(self, context, key, value):
  75. varname = get_varname()
  76. context[varname][key].append(value)
  77. return ''
  78. register.tag(AddData)
  79. class WithData(SekizaiTag):
  80. name = 'with_data'
  81. options = Options(
  82. Argument('name'),
  83. 'as',
  84. Argument('variable', resolve=False),
  85. blocks=[
  86. ('end_with_data', 'inner_nodelist'),
  87. ],
  88. parser_class=SekizaiParser,
  89. )
  90. def render_tag(self, context, name, variable, inner_nodelist, nodelist):
  91. rendered_contents = nodelist.render(context)
  92. varname = get_varname()
  93. data = context[varname][name]
  94. context.push()
  95. context[variable] = data
  96. inner_contents = inner_nodelist.render(context)
  97. context.pop()
  98. return '%s\n%s' % (inner_contents, rendered_contents)
  99. register.tag(WithData)
  100. class Addtoblock(SekizaiTag):
  101. name = 'addtoblock'
  102. options = Options(
  103. Argument('name'),
  104. Flag('strip', default=False, true_values=['strip']),
  105. parser_class=AddtoblockParser,
  106. )
  107. def render_tag(self, context, name, strip, nodelist):
  108. rendered_contents = nodelist.render(context)
  109. if strip:
  110. rendered_contents = rendered_contents.strip()
  111. varname = get_varname()
  112. context[varname][name].append(rendered_contents)
  113. return ""
  114. register.tag(Addtoblock)