def templatetag_raw(parser, token):
"""
Return a TextNode with all html not parsed, used for templatetags
that need to not be parsed : the `nocache` one and the `RAW` one,
used to surround cached html (to be not parsed again)
Based on http://www.holovaty.com/writing/django-two-phased-rendering/
"""
# Whatever is between {% nocache %} and {% endnocache %} will be preserved as
# raw, unrendered template code.
text = []
parse_until = 'end%s' % token.contents
tag_mapping = {
template.TOKEN_TEXT: ('', ''),
template.TOKEN_VAR: ('{{', '}}'),
template.TOKEN_BLOCK: ('{%', '%}'),
template.TOKEN_COMMENT: ('{#', '#}'),
}
# By the time this template tag is called, the template system has already
# lexed the template into tokens. Here, we loop over the tokens until
# {% endraw %} and parse them to TextNodes. We have to add the start and
# end bits (e.g. "{{" for variables) because those have already been
# stripped off in a previous part of the template-parsing process.
while parser.tokens:
token = parser.next_token()
if token.token_type == template.TOKEN_BLOCK and token.contents == parse_until:
return template.TextNode(u''.join(text))
start, end = tag_mapping[token.token_type]
text.append(u'%s%s%s' % (start, token.contents, end))
parser.unclosed_block_tag(parse_until)
def raw(parser, token):
# Whatever is between {% verbatim %} and {% endverbatim %}
# will be preserved as
# verbatim, unrendered template code.
text = []
parse_until = 'endverbatim'
tag_mapping = {
template.TOKEN_TEXT: ('', ''),
template.TOKEN_VAR: ('{{', '}}'),
template.TOKEN_BLOCK: ('{%', '%}'),
template.TOKEN_COMMENT: ('{#', '#}'),
}
# By the time this template tag is called, the template
# system has already lexed the template into tokens.
# Here, we loop over the tokens until
# {% endverbatim %} and parse them to TextNodes.
# We have to add the start and
# end bits (e.g. "{{" for variables) because those
# have already been stripped off in a previous
# part of the template-parsing process.
while parser.tokens:
token = parser.next_token()
if token.token_type == template.TOKEN_BLOCK and \
token.contents == parse_until:
return template.TextNode(u''.join(text))
start, end = tag_mapping[token.token_type]
if token.contents.startswith('='):
text.append(u'%s%s %s' % (start, token.contents, end))
else:
text.append(u'%s %s %s' % (start, token.contents, end))
parser.unclosed_block_tag(parse_until)
def app_installed(parser, token):
"""
Check if app with given name installed:
{% app 'app.plugins.app' %}
...
{% elseapp %}
...
{% endapp %}
"""
tag_name, app_name = token.split_contents()
app_name = app_name[1:-1]
if app_name in settings.INSTALLED_APPS:
nodelist_true = parser.parse(('elseapp', 'endapp'))
token = parser.next_token()
if token.contents == 'elseapp':
parser.skip_past('endapp')
return AppNode(nodelist_true, app_name)
while parser.tokens:
token = parser.next_token()
if token.token_type == 2 and token.contents in ('elseapp', 'endapp'):
break
if token.contents == 'elseapp':
nodelist_false = parser.parse(('endapp', ))
parser.delete_first_token()
else:
return template.TextNode('')
return AppNode(nodelist_false, app_name)
def raw(parser, token):
# Whatever is between {% raw %} and {% endraw %} will be preserved as
# raw, unrendered template code.
# If 'silent' is passed in -- {% raw silent %} -- then the resulting output
# will not contain the {% raw %} and {% endraw %} tags themselves.
# Otherwise, the output will include an {% endraw %} at the start and
# {% raw %} at the end, so that other parts of the page aren't vulnerable
# to Django template escaping injection.
silent = 'silent' in token.contents
if silent:
text = []
else:
text = ['{% endraw %}']
parse_until = 'endraw'
tag_mapping = {
template.TOKEN_TEXT: ('', ''),
template.TOKEN_VAR: ('{{', '}}'),
template.TOKEN_BLOCK: ('{%', '%}'),
template.TOKEN_COMMENT: ('{#', '#}'),
}
# By the time this template tag is called, the template system has already
# lexed the template into tokens. Here, we loop over the tokens until
# {% endraw %} and parse them to TextNodes. We have to add the start and
# end bits (e.g. "{{" for variables) because those have already been
# stripped off in a previous part of the template-parsing process.
while parser.tokens:
token = parser.next_token()
if token.token_type == template.TOKEN_BLOCK and token.contents == parse_until:
if not silent:
text.append('{% raw silent %}')
return template.TextNode(u''.join(text))
start, end = tag_mapping[token.token_type]
text.append(u'%s%s%s' % (start, token.contents, end))
parser.unclosed_block_tag(parse_until)
def do_static_nonce(parser, token):
tokens = token.split_contents()
if len(tokens) > 2 or not quoted_attribute(tokens[1]):
raise template.TemplateSyntaxError(
'syntax is {% static_nonce "<file_name>" %}')
filename = unquote_attribute(tokens[1])
fullpath = os.path.join(settings.STATIC_DIR, filename)
if not os.path.exists(fullpath):
raise template.TemplateSyntaxError('%s does not exist' % filename)
nonce = hash(os.stat(fullpath))
return template.TextNode('%s%s?%i' %
(settings.STATIC_BASE_URL, filename, nonce))
def simile(parser, token, apps, forceBundle=False):
"""Generic function for simile api inclusions
"""
args = token.split_contents()[1:]
simileurl = reverse('static', kwargs={'path': 'simile/'})
opts = {'bundle': 'true', 'autoCreate': 'true'}
for arg in args:
try:
k, v = arg.split('=', 1)
if k in opts:
opts[k] = v
except ValueError:
pass
bundle = opts['bundle'] == 'false' and 'bundle=false' or None
if bundle is None and forceBundle:
bundle = 'bundle=true'
autoCreate = opts['autoCreate'] == 'false' and 'autoCreate=false' or None
ajax_params = '&'.join(filter(None, [bundle]))
if ajax_params:
ajax_params = '?' + ajax_params
app_params = '&'.join(filter(None, [bundle, autoCreate]))
if app_params:
app_params = '?' + app_params
script_head = '''<script type="text/javascript">
(function() {
'''
script_tail = '''
})();
</script>
<script type="text/javascript" '''\
'''src="%(base)sajax/simile-ajax-api.js%(params)s"></script>
''' % {'base': simileurl, 'params': ajax_params}
loaders = []
next = None
params = app_params
for app in reversed(apps):
loaders += ['function load_%s() {' % app]
if next is not None:
loaders += [' window.SimileAjax_onLoad = load_%s;' % next]
loaders += [
' SimileAjax.includeJavascriptFile(document, "%(base)s%(app)s/'\
'%(app)s-api.js%(params)s");' % \
{'base': simileurl, 'app': app, 'params': params},
'};']
next = app
params = ajax_params
loaders += ['window.SimileAjax_onLoad = load_%s;' % next]
out = (script_head + '\n '.join(loaders) + script_tail)
return template.TextNode(out)
def do_include_raw(parser, token):
"""
Performs a template include without parsing the context, just dumps the template in.
"""
bits = token.split_contents()
if len(bits) != 2:
raise TemplateSyntaxError, "%r tag takes one argument: the name of the template to be included" % bits[0]
template_name = bits[1]
if template_name[0] in ('"', "'") and template_name[-1] == template_name[0]:
template_name = template_name[1:-1]
source, path = load_template_source(template_name)
return template.TextNode(source)
def do_include_ich(parser, token):
bits = token.split_contents()
template_name = bits[1]
if template_name[0] in ('"', "'") and template_name[-1] == template_name[0]:
template_name = template_name[1:-1]
block_name, block_type = basename(template_name).rsplit('.', 1)
source, path = _loader.load_template_source(template_name)
render = '<script id="tpl_%s" type="text/%s">\n%s\n</script>' % (block_name, block_type, source)
if 'partial' in bits:
render += '<script id="tpl_partial_%s" type="text/%s" class="partial">\n%s\n</script>' % (block_name, block_type, source)
return template.TextNode(render)
def __init__(self, var_user, var_entry, is_admin, pred, api_call,
link_class, content):
self.var_user = template.Variable(var_user)
self.var_entry = template.Variable(var_entry)
self.var_is_admin = None
try:
template.Variable(is_admin)
except:
pass
self.pred = pred
self.api_call = api_call
self.link_class = link_class
if not isinstance(content, template.Node):
self.content = template.TextNode(content)
else:
self.content = content
def do_include_raw(parser, token):
"""
Performs a template include without parsing the context, just dumps
the template in.
Source: http://djangosnippets.org/snippets/1684/
"""
bits = token.split_contents()
if len(bits) != 2:
raise template.TemplateSyntaxError(
"%r tag takes one argument: the name of the template "
"to be included" % bits[0]
)
template_name = bits[1]
if template_name[0] in ('"', "'") and template_name[-1] == template_name[0]:
template_name = template_name[1:-1]
source, path = Loader.load_template_source(template_name)
return template.TextNode(source)
def do_include_raw(parser, token):
"""Perform a raw template include.
This means to include the template without parsing context, just dump the
template in.
Source: http://djangosnippets.org/snippets/1684/
"""
bits = token.split_contents()
if len(bits) != 2:
excp_msg = ("%r tag takes one argument: the name of the template to "
"be included" % bits[0])
raise template.TemplateSyntaxError(excp_msg)
template_name = bits[1]
if (template_name[0] in ('"', "'")
and template_name[-1] == template_name[0]):
template_name = template_name[1:-1]
template_loader = Loader()
source, path = template_loader.load_template_source(template_name)
return template.TextNode(source)
def raw(parser, token):
# Whatever is between {% raw %} and {% endraw %} will be preserved as
# raw, unrendered template code.
text = []
parse_until = "endraw"
tag_mapping = {
template.TOKEN_TEXT: ("", ""),
template.TOKEN_VAR: ("{{", "}}"),
template.TOKEN_BLOCK: ("{%", "%}"),
template.TOKEN_COMMENT: ("{#", "#}"),
}
# By the time this template tag is called, the template system has already
# lexed the template into tokens. Here, we loop over the tokens until
# {% endraw %} and parse them to TextNodes. We have to add the start and
# end bits (e.g. "{{" for variables) because those have already been
# stripped off in a previous part of the template-parsing process.
while parser.tokens:
token = parser.next_token()
if token.token_type == template.TOKEN_BLOCK and token.contents == parse_until:
return template.TextNode(u"".join(text))
start, end = tag_mapping[token.token_type]
text.append(u"%s%s%s" % (start, token.contents, end))
parser.unclosed_block_tag(parse_until)
def raw(parser, token):
# ro: thanks to EveryBlock for this code snippet
# Whatever is between {% raw %} and {% endraw %} will skip the cache
# so that e.g. 'usernames' can be refreshed while reports remain cached
text = []
parse_until = 'endraw'
tag_mapping = {
template.TOKEN_TEXT: ('', ''),
template.TOKEN_VAR: ('{{', '}}'),
template.TOKEN_BLOCK: ('{%', '%}'),
template.TOKEN_COMMENT: ('{#', '#}'),
}
# By the time this template tag is called, the template system has already
# lexed the template into tokens. Here, we loop over the tokens until
# {% endraw %} and parse them to TextNodes. We have to add the start and
# end bits (e.g. "{{" for variables) because those have already been
# stripped off in a previous part of the template-parsing process.
while parser.tokens:
token = parser.next_token()
if token.token_type == template.TOKEN_BLOCK and token.contents == parse_until:
return template.TextNode(u''.join(text))
start, end = tag_mapping[token.token_type]
text.append(u'%s%s%s' % (start, token.contents, end))
parser.unclosed_block_tag(parse_until)
def make_text_or_variable_node(parser, expression):
if quoted_attribute(expression):
return template.TextNode(unquote_attribute(expression))
else:
return template.VariableNode(parser.compile_filter(expression))
