def test_phased(self):
context = Context({'test_var': 'TEST'})
self.assertRaises(TemplateSyntaxError, compile_string(self.test_template, None).render, context)
context = Context({
'test_var': 'TEST',
'test_condition': True,
})
first_render = compile_string(self.test_template, None).render(context)
pickled_context = '{# stashed context: "gAJ9cQAoVQ50ZXN0X2NvbmRpdGlvbnEBiFUKY3NyZl90b2tlbnECVQtOT1RQUk9WSURFRHEDVQh0ZXN0X3ZhcnEEVQRURVNUcQV1Lg==" #}'
self.assertEqual(first_render, '%(delimiter)s{%% if 1 %%}test{%% endif %%}{%% if test_condition %%}stashed{%% endif %%}%(pickled_context)s%(delimiter)sTEST' %
dict(delimiter=settings.PHASED_SECRET_DELIMITER, pickled_context=pickled_context))
def test_phased(self):
context = Context({'test_var': 'TEST'})
self.assertRaises(TemplateSyntaxError, compile_string(self.test_template, None).render, context)
context = Context({
'test_var': 'TEST',
'test_condition': True,
})
first_render = compile_string(self.test_template, None).render(context)
pickled_context = '{# context "gAJ9cQEoVQ50ZXN0X2NvbmRpdGlvbnECiFUKY3NyZl90b2tlbnEDVQtOT1RQUk9WSURFRHEEVQh0ZXN0X3ZhcnEFVQRURVNUcQZ1Lg==" endcontext #}'
pickled_components = '{# components "gAJdcQFVH3BoYXNlZC50ZW1wbGF0ZXRhZ3MucGhhc2VkX3RhZ3NxAmEu" endcomponents #}'
self.assertEqual(first_render, '%(delimiter)s{%% if 1 %%}test{%% endif %%}{%% if test_condition %%}stashed{%% endif %%}%(pickled_context)s%(pickled_components)s%(delimiter)sTEST' % dict(delimiter=settings.SECRET_DELIMITER, pickled_context=pickled_context, pickled_components=pickled_components))
def test_phased(self):
context = Context({'test_var': 'TEST'})
self.assertRaises(TemplateSyntaxError, compile_string(self.test_template, None).render, context)
context = Context({
'test_var': 'TEST',
'test_condition': True,
})
first_render = compile_string(self.test_template, None).render(context)
pickled_context = '{# stashed context: "gAJ9cQAoVQ50ZXN0X2NvbmRpdGlvbnEBiFUKY3NyZl90b2tlbnECVQtOT1RQUk9WSURFRHEDVQh0ZXN0X3ZhcnEEVQRURVNUcQV1Lg==" #}'
self.assertEqual(first_render, '%(delimiter)s{%% if 1 %%}test{%% endif %%}{%% if test_condition %%}stashed{%% endif %%}%(pickled_context)s%(delimiter)sTEST' %
dict(delimiter=settings.PHASED_SECRET_DELIMITER, pickled_context=pickled_context))
def render(self, name, value, attrs=None):
result = []
value = value or ""
result.append(super(AdminTemplateEditWidget, self).render(name, value, attrs))
try:
compile_string(value, None)
result.append(u'<p class="template ok">%s</p>' % _('Template syntax is valid'))
except (TemplateSyntaxError, TemplateDoesNotExist), e:
msg = _('Template has following errors:')
error = e
if isinstance(e, TemplateDoesNotExist):
error = _('Template does not exist: %s') % e
result.append('<p class="template error"><span>%s</span> %s</p>' % (msg, error))
def test_phasedcache(self):
self.assertEqual(len(cache._cache.keys()), 0)
request = self.factory.get('/')
context = RequestContext(request, {'test_var': 'Testing'})
rendering = compile_string(self.test_template, None).render(context)
self.assertEqual(rendering, 'OtherPartTesting/TEST')
self.assertEqual(len(cache._cache.keys()), 1)
cached_value = cache.get('template.cache.phased_test.d41d8cd98f00b204e9800998ecf8427e')
self.assertIsNotNone(cached_value)
self.assertTrue(cached_value.startswith('Testing'))
request = self.factory.get('/path/')
# Do not make test_var available, should be in cache
context = RequestContext(request)
rendering = compile_string(self.test_template, None).render(context)
self.assertEqual(rendering, 'OtherPartTesting/path/TEST')
def test_phasedcache(self):
self.assertEqual(len(cache._cache.keys()), 0)
request = self.factory.get('/')
context = RequestContext(request, {'test_var': 'Testing'})
rendering = compile_string(self.test_template, None).render(context)
self.assertEqual(rendering, 'OtherPartTesting/TEST')
self.assertEqual(len(cache._cache.keys()), 1)
cached_value = cache.get('template.cache.phased_test.d41d8cd98f00b204e9800998ecf8427e')
self.assertIsNotNone(cached_value)
self.assertTrue(cached_value.startswith('Testing'))
request = self.factory.get('/path/')
# Do not make test_var available, should be in cache
context = RequestContext(request)
rendering = compile_string(self.test_template, None).render(context)
self.assertEqual(rendering, 'OtherPartTesting/path/TEST')
def test_phased(self):
context = Context({'test_var': 'TEST'})
first_render = compile_string(self.test_template, None).render(context)
self.assertEqual(
first_render,
'fancydelimiter{%% if 1 %%}test{%% endif %%}%sfancydelimiterTEST' %
pickle_context(backup_csrf_token(context)))
def render_variables(self):
context = {}
locale_variables = self.locale_variables_from_obj()
variables = [
str(var_name.filter_expression.token) for var_name in
compile_string(self.text2convert, self.text2convert)
if isinstance(var_name, VariableNode)
]
msg = _("Doesn't exist this variable '%(field)s' for '%(object)s'.")
try:
for field in variables:
context.update({
field:
getattr(
self.obj,
locale_variables
and locale_variables.get(field, field)
or field, # get real variable on obj
msg % {
'field': field,
'object': self.obj._meta.verbose_name
})
})
context = Context(context)
return mark_safe('%s' %
Template(self.text2convert).render(context))
except Exception, error:
raise TranslateVariableObjectError, error
def render(self, context):
# pagelets can automagically use pagelets templatetags
# in order to remove boilerplate
loaded_cms = AUTO_LOAD_TEMPLATE_TAGS + self.content
"""
skip the first portions of render_to_string() ( finding the template )
and go directly to compiling the template/pagelet
render_to_string abbreviated:
def render_to_string(template_name, dictionary=None, context_instance=None):
t = select/get_template(template_name)
template = get_template_from_string(source, origin, template_name)
return Template(source, origin, name)
t.render(context_instance)
"""
#XXX is this what the origin should be?
origin = StringOrigin('pagelet: %s' % self.slug)
compiled = compile_string(loaded_cms, origin).render(context)
try:
if self.type in ('html', 'tinymce', 'wymeditor'):
html = compiled
elif self.type == "textile":
from textile import textile
html = textile(str(compiled))
elif self.type == "markdown":
from markdown import markdown
html = markdown(compiled)
return html
except TemplateSyntaxError, e:
return 'Syntax error, %s' % e
def render(self, context):
# pagelets can automagically use pagelets templatetags
# in order to remove boilerplate
loaded_cms = conf.AUTO_LOAD_TEMPLATE_TAGS + self.content
"""
skip the first portions of render_to_string() ( finding the template )
and go directly to compiling the template/pagelet
render_to_string abbreviated:
def render_to_string(template_name, dictionary=None, context_instance=None):
t = select/get_template(template_name)
template = get_template_from_string(source, origin, template_name)
return Template(source, origin, name)
t.render(context_instance)
"""
#XXX is this what the origin should be?
origin = StringOrigin('pagelet: %s' % self.slug)
compiled = compile_string(loaded_cms, origin).render(context)
try:
if self.type in ('html', 'tinymce', 'wymeditor'):
html = compiled
elif self.type == "textile":
from textile import textile
html = textile(str(compiled))
elif self.type == "markdown":
from markdown import markdown
html = markdown(compiled)
return html
except TemplateSyntaxError as e:
return 'Syntax error, %s' % e
raise Exception("Unsupported template content type '%s'" %
self.content.content_type)
def test_second_pass(self):
request = HttpRequest()
request.method = 'GET'
first_render = compile_string(self.test_template, None).render(Context({'test_var': 'TEST'}))
second_render = second_pass_render(request, first_render)
self.assertEqual(second_render, 'firstsecondTEST')
def test_phased(self):
context = Context({'test_var': 'TEST'})
first_render = compile_string(self.test_template, None).render(context)
original_context = unpickle_context(first_render)
self.assertNotEqual(flatten_context(context), original_context)
pickled_context = pickle_context(Context({'csrf_token': 'NOTPROVIDED'}))
self.assertEqual(first_render, '%(delimiter)s{%% if 1 %%}test{%% endif %%}%(pickled_context)s%(delimiter)sTEST' %
dict(delimiter=settings.PHASED_SECRET_DELIMITER, pickled_context=pickled_context))
def test_phased(self):
context = Context({'test_var': 'TEST'})
first_render = compile_string(self.test_template, None).render(context)
original_context = unpickle_context(first_render)
self.assertNotEqual(flatten_context(context), original_context)
pickled_context = pickle_context(Context({'csrf_token': 'NOTPROVIDED'}))
self.assertEqual(first_render, '%(delimiter)s{%% if 1 %%}test{%% endif %%}%(pickled_context)s%(delimiter)sTEST' %
dict(delimiter=settings.PHASED_SECRET_DELIMITER, pickled_context=pickled_context))
def testViewNonexistentPagelet(self):
template_str = """{% spaceless %}
{% load pagelet_tags %}
{% render_pagelet 'nonexistent-pagelet' %}
{% endspaceless %}"""
origin = StringOrigin('test')
compiled = compile_string(template_str, origin).render(Context())
self.assertEqual(compiled, '<div class="pagelet nonexistent-pagelet"><div class="pagelet-content"></div></div>')
def test_phased(self):
context = Context({'test_var': 'TEST'})
first_render = compile_string(self.test_template, None).render(context)
self.assertEqual(
first_render,
'%(delimiter)s{%% load phased_tags %%}{%% phased %%}{%% if 1 %%}first{%% endif %%}{%% endphased %%}{%% if 1 %%}second{%% endif %%}%(pickled_context)s%(delimiter)sTEST'
% dict(delimiter=settings.PHASED_SECRET_DELIMITER,
pickled_context=pickle_context(backup_csrf_token(context))))
def test_phased(self):
context = Context({'test_var': 'TEST'})
first_render = compile_string(self.test_template, None).render(context)
original_context = unpickle_context(first_render)
self.assertNotEqual(flatten_context(context), original_context)
pickled_context = '{# context "gAJ9cQFVCmNzcmZfdG9rZW5xAlULTk9UUFJPVklERURxA3Mu" endcontext #}'
pickled_components = '{# components "gAJdcQFVH3BoYXNlZC50ZW1wbGF0ZXRhZ3MucGhhc2VkX3RhZ3NxAmEu" endcomponents #}'
self.assertEqual(first_render, '%(delimiter)s{%% if 1 %%}test{%% endif %%}%(pickled_context)s%(pickled_components)s%(delimiter)sTEST' % dict(delimiter=settings.SECRET_DELIMITER, pickled_context=pickled_context, pickled_components=pickled_components))
def test_phased(self):
context = Context({'test_var': 'TEST'})
pickled_context = '{# stashed context: "gAJ9cQAoVQpjc3JmX3Rva2VucQFVC05PVFBST1ZJREVEcQJVCHRlc3RfdmFycQNVBFRFU1RxBHUu" #}'
first_render = compile_string(self.test_template, None).render(context)
self.assertEqual(
first_render,
'%(delimiter)s{%% if 1 %%}test{%% endif %%}{%% if test_condition %%}stashed{%% endif %%}%(pickled_context)s%(delimiter)sTEST%(delimiter)s{%% if 1 %%}test2{%% endif %%}{%% if test_condition2 %%}stashed{%% endif %%}%(pickled_context)s%(delimiter)s'
% dict(delimiter=settings.PHASED_SECRET_DELIMITER,
pickled_context=pickled_context))
def test_second_pass(self):
request = self.factory.get('/')
context = Context({
'test_var': 'TEST',
'test_condition': True,
'test_condition2': True,
})
first_render = compile_string(self.test_template, None).render(context)
second_render = second_pass_render(request, first_render)
self.assertEqual(second_render, 'teststashedTESTtest2stashed')
def test_second_pass(self):
request = self.factory.get('/')
context = Context({
'test_var': 'TEST',
'test_condition': True,
'test_condition2': True,
})
first_render = compile_string(self.test_template, None).render(context)
second_render = second_pass_render(request, first_render)
self.assertEqual(second_render, 'teststashedTESTtest2stashed')
def test_second_pass(self):
request = HttpRequest()
request.method = 'GET'
context = Context({
'test_var': 'TEST',
'test_condition': True,
'test_condition2': True,
})
first_render = compile_string(self.test_template, None).render(context)
second_render = second_pass_render(request, first_render)
self.assertEqual(second_render, 'teststashedTESTtest2stashed')
def testViewNonexistentPagelet(self):
template_str = """{% spaceless %}
{% load pagelet_tags %}
{% render_pagelet 'nonexistent-pagelet' %}
{% endspaceless %}"""
origin = StringOrigin('test')
compiled = compile_string(template_str, origin).render(Context())
self.assertEqual(
compiled,
'<div class="pagelet nonexistent-pagelet"><div class="pagelet-content"></div></div>'
)
def test_second_pass(self):
request = self.factory.get('/')
context = Context({
'test_var': 'TEST',
'test_var2': 'TEST2',
'test_condition': True,
})
first_render = compile_string(self.test_template, None).render(context)
original_context = unpickle_context(first_render)
self.assertEqual(original_context.get('test_var'), 'TEST')
second_render = second_pass_render(request, first_render)
self.assertEqual(second_render, 'teststashedTEST')
def test_second_pass(self):
request = self.factory.get('/')
context = Context({
'test_var': 'TEST',
'test_var2': 'TEST2',
'test_condition': True,
})
first_render = compile_string(self.test_template, None).render(context)
original_context = unpickle_context(first_render)
self.assertEqual(original_context.get('test_var'), 'TEST')
second_render = second_pass_render(request, first_render)
self.assertEqual(second_render, 'teststashedTEST')
def render_variables(self):
context ={}
locale_variables = self.locale_variables_from_obj()
variables = [
str(var_name.filter_expression.token)
for var_name in compile_string(self.text2convert,self.text2convert)
if isinstance(var_name,VariableNode)
]
msg=_("Doesn't exist this variable '%(field)s' for '%(object)s'.")
try:
for field in variables:
context.update({
field:getattr(
self.obj,
locale_variables and locale_variables.get(field,field) or field, # get real variable on obj
msg % {'field': field, 'object': self.obj._meta.verbose_name }
)
})
context=Context(context)
return mark_safe('%s' % Template(self.text2convert).render(context))
except Exception, error:
raise TranslateVariableObjectError, error
def test_phased(self):
context = Context({'test_var': 'TEST'})
first_render = compile_string(self.test_template, None).render(context)
pickled_components = '{# components "gAJdcQFVH3BoYXNlZC50ZW1wbGF0ZXRhZ3MucGhhc2VkX3RhZ3NxAmEu" endcomponents #}'
self.assertEqual(first_render, '%(delimiter)s{%% load phased_tags %%}{%% phased %%}{%% if 1 %%}first{%% endif %%}{%% endphased %%}{%% if 1 %%}second{%% endif %%}%(pickled_context)s%(pickled_components)s%(delimiter)sTEST' % dict(delimiter=settings.SECRET_DELIMITER, pickled_context=pickle_context(backup_csrf_token(context)), pickled_components=pickled_components))
def test_phased(self):
context = Context({'test_var': 'TEST'})
first_render = compile_string(self.test_template, None).render(context)
pickled_components = '{# components "gAJdcQFVH3BoYXNlZC50ZW1wbGF0ZXRhZ3MucGhhc2VkX3RhZ3NxAmEu" endcomponents #}'
self.assertEqual(first_render, 'fancydelimiter{%% if 1 %%}test{%% endif %%}%s%sfancydelimiterTEST' % (pickle_context(backup_csrf_token(context)), pickled_components))
for column_index, order in query.sorting_columns]
queryset = queryset.order_by(*order_by)
# 3) Apply offset/limit
queryset = queryset[query.iDisplayStart:query.iDisplayStart + query.iDisplayLength]
# Compute the response
# Note, despite the 'aaData'' identifier we're
# returing aoData-typed result (array of objects)
# print queryset.values(*[column.filter_expr for column in self.columns])
response['aaData'] = [
dict([(column.name, column.callback(object))
for column in self.columns])
for object in queryset]
return response
simple_nodelist = compile_string('{{ value }}', None)
class TableBackend(_BackendBase):
"""
Database backend for data tables.
Stores and processes/computes the data in the database.
"""
def __init__(self, table):
self.table = table
def _render_cell(self, col, data):
"""Render data for a column.
def test_phased(self):
context = Context({'test_var': 'TEST'})
pickled_context = '{# context "gAJ9cQEoVQpjc3JmX3Rva2VucQJVC05PVFBST1ZJREVEcQNVCHRlc3RfdmFycQRVBFRFU1RxBXUu" endcontext #}'
pickled_components = '{# components "gAJdcQFVH3BoYXNlZC50ZW1wbGF0ZXRhZ3MucGhhc2VkX3RhZ3NxAmEu" endcomponents #}'
first_render = compile_string(self.test_template, None).render(context)
self.assertEqual(first_render, '%(delimiter)s{%% if 1 %%}test{%% endif %%}{%% if test_condition %%}stashed{%% endif %%}%(pickled_context)s%(pickled_components)s%(delimiter)sTEST%(delimiter)s{%% if 1 %%}test2{%% endif %%}{%% if test_condition2 %%}stashed{%% endif %%}%(pickled_context)s{# components "gAJdcQFVH3BoYXNlZC50ZW1wbGF0ZXRhZ3MucGhhc2VkX3RhZ3NxAmEu" endcomponents #}%(delimiter)s' % dict(delimiter=settings.SECRET_DELIMITER, pickled_context=pickled_context, pickled_components=pickled_components))
def compile_string(self, url, template_str):
origin = StringOrigin(url)
return compile_string(template_str, origin).render(Context())
def test_second_pass(self):
request = self.factory.get('/')
first_render = compile_string(self.test_template, None).render(Context({'test_var': 'TEST'}))
second_render = second_pass_render(request, first_render)
self.assertEqual(second_render, 'firstsecondTEST')
queryset = queryset.order_by(*order_by)
# 3) Apply offset/limit
queryset = queryset[query.iDisplayStart:query.iDisplayStart +
query.iDisplayLength]
# Compute the response
# Note, despite the 'aaData'' identifier we're
# returing aoData-typed result (array of objects)
# print queryset.values(*[column.filter_expr for column in self.columns])
response['aaData'] = [
dict([(column.name, column.callback(object))
for column in self.columns]) for object in queryset
]
return response
simple_nodelist = compile_string('{{ value }}', None)
class TableBackend(_BackendBase):
"""
Database backend for data tables.
Stores and processes/computes the data in the database.
"""
def __init__(self, table):
self.table = table
def _render_cell(self, col, data):
"""Render data for a column.
The intent here is to match as precisely as possible the way a cell
def compile_string(self, url, template_str):
origin = StringOrigin(url)
return compile_string(template_str, origin).render(Context())
def test_phased(self):
context = Context({'test_var': 'TEST'})
pickled_context = '{# stashed context: "gAJ9cQAoVQpjc3JmX3Rva2VucQFVC05PVFBST1ZJREVEcQJVCHRlc3RfdmFycQNVBFRFU1RxBHUu" #}'
first_render = compile_string(self.test_template, None).render(context)
self.assertEqual(first_render, '%(delimiter)s{%% if 1 %%}test{%% endif %%}{%% if test_condition %%}stashed{%% endif %%}%(pickled_context)s%(delimiter)sTEST%(delimiter)s{%% if 1 %%}test2{%% endif %%}{%% if test_condition2 %%}stashed{%% endif %%}%(pickled_context)s%(delimiter)s' %
dict(delimiter=settings.PHASED_SECRET_DELIMITER, pickled_context=pickled_context))
def test_phased(self):
context = Context({'test_var': 'TEST'})
first_render = compile_string(self.test_template, None).render(context)
self.assertEqual(first_render, '%(delimiter)s{%% load phased_tags %%}{%% phased %%}{%% if 1 %%}first{%% endif %%}{%% endphased %%}{%% if 1 %%}second{%% endif %%}%(pickled_context)s%(delimiter)sTEST' %
dict(delimiter=settings.PHASED_SECRET_DELIMITER, pickled_context=pickle_context(backup_csrf_token(context))))
def parse(self, *args):
nodelist = template.NodeList()
nodelist.extend(template.compile_string(text, None))
return nodelist
def test_phased(self):
context = Context({'test_var': 'TEST'})
first_render = compile_string(self.test_template, None).render(context)
self.assertEqual(first_render, 'fancydelimiter{%% if 1 %%}test{%% endif %%}%sfancydelimiterTEST' % pickle_context(backup_csrf_token(context)))
def test_second_pass(self):
request = self.factory.get('/')
first_render = compile_string(self.test_template, None).render(Context({'test_var': 'TEST'}))
second_render = second_pass_render(request, first_render)
self.assertEqual(second_render, 'firstsecondTEST')
