def brick_table_data_status(parser, token):
"""Mark some <td> in table-bricks with specific HTML attribute.
Generally markers are 'primary' and 'action', but you can use your own.
Example:
{% extends 'creme_core/bricks/base/table.html' %}
{% load creme_bricks %}
...
{% block brick_table_rows %}
<tr>
<td {% brick_table_data_status primary %}> ... </td> {# Will have "data-table-primary-column" attribute #}
...
</tr>
{% endblock %}
"""
tokens = token.split_contents() # Splitting by None == splitting by spaces.
if len(tokens) < 2:
raise TemplateSyntaxError('"{!r}" tag requires at least one argument.'.format(tokens[0]))
return TextNode(' '.join('data-table-{}-column'.format(t) for t in tokens[1:]))
def nevercache(parser, token):
"""
Tag for two phased rendering. Converts enclosed template
code and content into text, which gets rendered separately
in ``mezzanine.core.middleware.UpdateCacheMiddleware``.
This is to bypass caching for the enclosed code and content.
"""
text = []
end_tag = "endnevercache"
tag_mapping = {
TOKEN_TEXT: ("", ""),
TOKEN_VAR: ("{{", "}}"),
TOKEN_BLOCK: ("{%", "%}"),
TOKEN_COMMENT: ("{#", "#}"),
}
delimiter = nevercache_token()
while parser.tokens:
token = parser.next_token()
token_type = token.token_type
if token_type == TOKEN_BLOCK and token.contents == end_tag:
return TextNode(delimiter + "".join(text) + delimiter)
start, end = tag_mapping[token_type]
text.append("%s%s%s" % (start, token.contents, end))
parser.unclosed_block_tag(end_tag)
def process_node_list(self, nodelist, context):
new_nodes = NodeList()
variable_nodes = []
i = nodelist.__len__() - 1
l = 0
while l <= i:
while l <= i:
this_node = nodelist[l]
node_class = this_node.__class__.__name__
if node_class == "ForNode":
this_node = self.assemble_for_node(this_node, context)
if node_class == "IfNode":
this_node = self.assemble_if_node(this_node, context)
if node_class == 'TextNode':
splitted = self.split_text_node(this_node.s)
for item in splitted:
new_nodes.append(item)
else:
new_nodes.append(this_node)
if "VariableNode" in node_class:
variable_nodes.append(new_nodes.__len__() - 1)
l = l + 1
schema_props = []
for item in variable_nodes:
node_in_question = new_nodes[item]
schema_prop = ''
if hasattr(node_in_question, 'filter_expression'):
filter_exp = str(node_in_question.filter_expression)
filter_exp = filter_exp.replace(self.object_name + '.', '')
# ensure ones with added template tags work properly
if '|' in filter_exp:
filter_exp = filter_exp[:filter_exp.find('|')]
try:
schema_prop = schemaprop(self.obj, filter_exp, item)
except:
e = sys.exc_info()[0]
raise TemplateSyntaxError(e)
schema_props.append(schema_prop)
prop_count = schema_props.__len__() - 1
prop_index = 0
while prop_index <= prop_count:
prior_node_counter = 1
this_prop = schema_props[prop_index]
prior_node = new_nodes[this_prop.variable_node - prior_node_counter]
found_prior = False
while not (found_prior or (prior_node_counter == this_prop.variable_node)):
if prior_node.__class__.__name__ == 'CloseTagNode':
prior_node.s = ' ' + str(this_prop) + prior_node.s
found_prior = True
elif prior_node.__class__.__name__ == 'OpenVoidNode':
found_prior = True
prior_node.s = prior_node.s + str(this_prop) + ' '
elif prior_node.__class__.__name__ == 'OpenTagNode':
found_prior = True
else:
prior_node_counter = prior_node_counter + 1
prior_node = new_nodes[this_prop.variable_node - prior_node_counter]
prop_index = prop_index + 1
scope = schemascope(self.obj)
top_text = "<" + self.html_class + ' '
if self.html_attribute:
top_text = top_text + self.html_attribute
if self.id_attr:
top_text = top_text + ' id="#' + self.id_attr + str(self.obj.pk) + '"'
top_text = top_text + ' itemscope itemtype=' + scope + '>'
bottom_text = "</" + self.html_class + ">"
topnode = TextNode(top_text)
bottomnode = TextNode(bottom_text)
new_nodes.insert(0, topnode)
new_nodes.append(bottomnode)
return new_nodes
def compress(context, data, name):
"""
Data is the string from the template (the list of js files in this case)
Name is either 'js' or 'css' (the sekizai namespace)
Basically passes the string through the {% compress 'js' %} template tag
Alternatively, if the block can contain a html comment structured like:
<!-- compress_options [params] -->
params can be: one of ['js','css'] and one or multiple of ['file','preload','inline']
"""
# separate compressable from uncompressable files
options = []
kind = name
m = re.search('<!-- *compress_options *([a-z ]+?) *-->', data)
if m is not None:
options_clean = re.sub(' +', ' ', m.groups()[0])
options = set(options_clean.split(' '))
if 'js' in options and 'css' not in options:
kind = 'js'
elif 'css' in options and 'js' not in options:
kind = 'css'
parser = get_class(settings.COMPRESS_PARSER)(data)
js_compressor, css_compressor = Compressor('js'), Compressor('css')
compressable_elements, expanded_elements, deferred_elements = [], [], []
if kind == 'js':
for elem in parser.js_elems():
attribs = parser.elem_attribs(elem)
try:
if 'src' in attribs:
js_compressor.get_basename(attribs['src'])
except UncompressableFileError:
if 'defer' in attribs:
deferred_elements.append(elem)
else:
expanded_elements.append(elem)
else:
compressable_elements.append(elem)
elif kind == 'css':
for elem in parser.css_elems():
attribs = parser.elem_attribs(elem)
try:
if parser.elem_name(elem) == 'link' and attribs['rel'].lower(
) == 'stylesheet':
css_compressor.get_basename(attribs['href'])
except UncompressableFileError:
expanded_elements.append(elem)
else:
compressable_elements.append(elem)
# reconcatenate them
results = []
data = ''.join(parser.elem_str(e) for e in expanded_elements)
expanded_node = CompressorNode(nodelist=TextNode(data),
kind=kind,
mode='file')
results.append(expanded_node.get_original_content(context=context))
if 'file' in options or len(options) == 0:
data = ''.join(parser.elem_str(e) for e in compressable_elements)
compressable_node = CompressorNode(nodelist=TextNode(data),
kind=kind,
mode='file')
tmp_result = compressable_node.render(context=context)
if 'defer' in options:
tmp_result = re.sub("></script>$", " defer=\"defer\"></script>",
tmp_result)
results.append(tmp_result)
if 'preload' in options:
data = ''.join(parser.elem_str(e) for e in compressable_elements)
compressable_node = CompressorNode(nodelist=TextNode(data),
kind=kind,
mode='preload')
results.append(compressable_node.render(context=context))
if 'inline' in options:
data = ''.join(parser.elem_str(e) for e in compressable_elements)
compressable_node = CompressorNode(nodelist=TextNode(data),
kind=kind,
mode='inline')
results.append(compressable_node.render(context=context))
data = ''.join(parser.elem_str(e) for e in deferred_elements)
deferred_node = CompressorNode(nodelist=TextNode(data),
kind=kind,
mode='file')
results.append(deferred_node.get_original_content(context=context))
return '\n'.join(results)
def date_format(parser, token):
return TextNode(settings.DATE_FORMAT_JS)
def verbatim_tags(parser, token, endtagname='', endtagnames=[]):
"""
Javascript templates (jquery, handlebars.js, mustache.js) use constructs like:
::
{{if condition}} print something{{/if}}
This, of course, completely screws up Django templates,
because Django thinks {{ and }} means something.
The following code preserves {{ }} tokens.
This version of verbatim template tag allows you to use tags
like url {% url name %}. {% trans "foo" %} or {% csrf_token %} within.
@returns a list of nodes.
"""
nodelist = NodeList()
while 1:
token = parser.tokens.pop(0)
if token.contents in endtagnames or token.contents == endtagname:
break
# special case, {{ block.super }} is something we don't want to escape!
# TODO: refactor this condition, token.split_contents should return
# only one string, block.super, otherwise we might be dealing with
# handlebars templating shenanigans
# FIXME: block.super not working
# if 'block.super' in token.contents:
# filter_expression = parser.compile_filter(token.contents)
# var_node = parser.create_variable_node(filter_expression)
# parser.extend_nodelist(nodelist, var_node, token)
# import pdb; pdb.set_trace()
if token.token_type == TOKEN_VAR:
parser.extend_nodelist(nodelist, TextNode('{{'), token)
parser.extend_nodelist(nodelist, TextNode(token.contents), token)
elif token.token_type == TOKEN_TEXT:
parser.extend_nodelist(nodelist, TextNode(token.contents), token)
elif token.token_type == TOKEN_BLOCK:
try:
command = token.contents.split()[0]
except IndexError:
parser.empty_block_tag(token)
try:
compile_func = parser.tags[command]
except KeyError:
parser.invalid_block_tag(token, command, None)
try:
node = compile_func(parser, token)
except template.TemplateSyntaxError, e:
if not parser.compile_function_error(token, e):
raise
parser.extend_nodelist(nodelist, node, token)
if token.token_type == TOKEN_VAR:
parser.extend_nodelist(nodelist, TextNode('}}'), token)
def version(parser, token):
return TextNode(util.version())