tags = set(['csrf_token']) def parse(self, parser): lineno = parser.stream.next().lineno return nodes.Output([ self.call_method('_render', [nodes.Name('csrf_token', 'load')]), ]).set_lineno(lineno) def _render(self, csrf_token): from django.template.defaulttags import CsrfTokenNode return Markup(CsrfTokenNode().render({'csrf_token': csrf_token})) # nicer import names load = LoadExtension url = URLExtension with_ = WithExtension cache = CacheExtension spaceless = SpacelessExtension csrf_token = CsrfTokenExtension register = Library() register.tag(load) register.tag(url) register.tag(with_) register.tag(cache) register.tag(spaceless) register.tag(csrf_token)
""" tags = set(['csrf_token']) def parse(self, parser): lineno = parser.stream.next().lineno return nodes.Output([ self.call_method('_render', [nodes.Name('csrf_token', 'load')]), ]).set_lineno(lineno) def _render(self, csrf_token): from django.template.defaulttags import CsrfTokenNode return Markup(CsrfTokenNode().render({'csrf_token': csrf_token})) # nicer import names load = LoadExtension url = URLExtension with_ = WithExtension cache = CacheExtension spaceless = SpacelessExtension csrf_token = CsrfTokenExtension register = Library() register.tag(load) register.tag(url) register.tag(with_) register.tag(cache) register.tag(spaceless) register.tag(csrf_token)
""" tags = ['spaceless'] def parse(self, parser): lineno = parser.stream.next().lineno body = parser.parse_statements(['name:endspaceless'], drop_needle=True) return nodes.CallBlock( self.call_method('_strip_spaces', [], [], None, None), [], [], body ).set_lineno(lineno) def _strip_spaces(self, caller=None): from django.utils.html import strip_spaces_between_tags return strip_spaces_between_tags(caller().strip()) # nicer import names load = LoadExtension url = URLExtension with_ = WithExtension cache = CacheExtension spaceless = SpacelessExtension register = Library() register.tag(load) register.tag(url) register.tag(with_) register.tag(cache) register.tag(spaceless)
""" tags = set(['static']) def parse(self, parser): stream = parser.stream lineno = stream.next().lineno path = parser.parse_expression() call_node = self.call_method('get_static_url', args=[path]) if stream.next_if('name:as'): var = nodes.Name(stream.expect('name').value, 'store') return nodes.Assign(var, call_node).set_lineno(lineno) else: return nodes.Output([call_node]).set_lineno(lineno) @classmethod def get_static_url(cls, path): return urljoin(PrefixExtension.get_uri_setting("STATIC_URL"), path) register.tag(GetStaticPrefixExtension) register.tag(GetMediaPrefixExtension) register.tag(StaticExtension) def static(path): return StaticExtension.get_static_url(path)
ImminentDeprecationWarning) elif name == 'depends': depends = value # positional arguments are source files elif name is None: files.append(value) else: raise template.TemplateSyntaxError( 'Unsupported keyword argument "%s"' % name) # capture until closing tag childnodes = parser.parse(("endassets", )) parser.delete_first_token() return AssetsNode(filters, depends, output, debug, files, childnodes) # If Coffin is installed, expose the Jinja2 extension try: from coffin.template import Library as CoffinLibrary except ImportError: register = template.Library() else: register = CoffinLibrary() from webassets.ext.jinja2 import AssetsExtension from django_assets.env import get_env register.tag(AssetsExtension, environment={'assets_environment': get_env()}) # expose the default Django tag register.tag('assets', assets)
"""Register a Jinja2 extension with a Coffin library object. """ from jinja2.ext import Extension from jinja2 import nodes class FooExtension(Extension): tags = set(['foo']) def parse(self, parser): parser.stream.next() return nodes.Const('{foo}') class FooWithConfigExtension(Extension): tags = set(['foo_ex']) def __init__(self, environment): Extension.__init__(self, environment) environment.extend( foo_custom_output='foo', ) def parse(self, parser): parser.stream.next() return nodes.Const('{%s}' % self.environment.foo_custom_output) from coffin.template import Library register = Library() register.tag(FooExtension) register.tag(FooWithConfigExtension, environment={'foo_custom_output': 'my_foo'})
'''If our token has a `source` attribute than template_debugging is enabled. If it's enabled create a valid source attribute for the Django template debugger''' if source_token: source = source_token.source[0], (source_token.source[1][0], source_token.source[1][1]) else: source = None return Jinja(Template(''.join(tokens), source=source)) def django_noop(parser, token): return DjangoNoop() register.tag('django', django_noop) register.tag('end_django', django_noop) class JinjaNoop(ext.Extension): tags = set(['jinja', 'end_jinja']) def parse(self, parser): while not parser.stream.current.type == 'block_end': parser.stream.next() return [] register.tag(JinjaNoop) class Django(ext.Extension):
from coffin.template import Library from django.template.loader import render_to_string from jinja2 import nodes from jinja2.ext import Extension register = Library() class MerchantExtension(Extension): tags = set(['render_integration']) def parse(self, parser): stream = parser.stream lineno = stream.next().lineno obj = parser.parse_expression() call_node = self.call_method('render_integration', args=[obj]) return nodes.Output([call_node]).set_lineno(lineno) @classmethod def render_integration(self, obj): form_str = render_to_string(obj.template, {'integration': obj}) return form_str register.tag(MerchantExtension)
"""Register a Django tag with a Coffin library object. """ from django.template import Node class FooNode(Node): def render(self, context): return u'{foo}' def do_foo(parser, token): return FooNode() from coffin.template import Library register = Library() register.tag('foo_coffin', do_foo)
class CdnExtension(PrefixExtension): tags = set(['cdn']) def parse(self, parser): stream = parser.stream lineno = stream.next().lineno path = parser.parse_expression() call_node = self.call_method('get_statc_url', args=[path]) if stream.next_if('name:as'): var = nodes.Name(stream.expect('name').value, 'store') return nodes.Assign(var, call_node).set_lineno(lineno) else: return nodes.Output([call_node]).set_lineno(lineno) @classmethod def get_statc_url(cls, path): if settings.DEBUG: return path f = StaticFile(path) return f.cdn_path register.tag(CdnExtension) def static(path): return CdnExtension.get_static_url(path)
Minifier = minify.MinifyJs extension = 'js' class JsIncludeExtension(JsExtension, IncludeExtension): tags = ['jsinclude', 'endjsinclude'] template = settings.JS_INCLUDE def _get_filename(self, request, include, minify): if minify or len(include) != 1: url = IncludeExtension._get_filename(self, request, include, minify) else: url = settings.MEDIA_URL + include[0] return url register.tag(JsIncludeExtension) class JsHeadExtension(JsIncludeExtension): tags = ['js_head', 'endjs_head'] template = settings.JS_HEAD_INCLUDE @contextfunction def _join_nodes(self, context, nodes): return super(JsHeadExtension, self)._join_nodes(context, nodes, separator=',') register.tag(JsHeadExtension) class JsHeadIncludeExtension(JsHeadExtension): """ wraps all nodes with a template <head>...</head> or head.js(...);
from jinja2.ext import do as j2do from jinja2.ext import loopcontrols from jinja2.ext import with_ from coffin.template import Library register = Library() register.tag(j2do) register.tag(loopcontrols) register.tag(with_)
class AddGuideExtension(Extension): """ Jinja2-version of the ``render_guides`` tag. """ tags = set(['add_guide']) def parse(self, parser): lineno = parser.stream.next().lineno args = [] while not parser.stream.current.test('block_end'): args.append(parser.parse_expression()) parser.stream.skip_if('comma') return nodes.Output([ self.call_method('_render', [nodes.Name('request', 'load'), nodes.List(args)]), ]).set_lineno(lineno) def _render(self, request, args): if not hasattr(request, 'current_guide_name_list'): request.current_guide_name_list = list() for name in args: request.current_guide_name_list.append(name) return '' @register.object def render_guides(request): return Markup(origin_render_guides({'request': request})) register.tag(AddGuideExtension)
class StaticExtension(CoffinStaticExtension): """Implements the {% static %} tag as provided by the ``staticfiles`` contrib module. Returns the URL to a file using staticfiles' storage backend. Usage:: {% static path [as varname] %} Examples:: {% static "myapp/css/base.css" %} {% static variable_with_path %} {% static "myapp/css/base.css" as admin_base_css %} {% static variable_with_path as varname %} """ @classmethod def get_static_url(cls, path): return super(StaticExtension, cls).get_static_url( staticfiles_storage.url(path)) register.tag(StaticExtension) def static(path): return StaticExtension.get_static_url(path)
# handle known keyword arguments if name == 'output': output = value elif name == 'filter': filter = value # positional arguments are source files elif name is None: files.append(value) else: raise template.TemplateSyntaxError('Unsupported keyword argument "%s"'%name) # capture until closing tag childnodes = parser.parse(("endassets",)) parser.delete_first_token() return AssetsNode(filter, output, files, childnodes) # if Coffin is installed, expose the Jinja2 extension try: from coffin.template import Library as CoffinLibrary except ImportError: register = template.Library() else: register = CoffinLibrary() from django_assets.jinja2.extension import AssetsExtension register.tag(AssetsExtension) # expose the default Django tag register.tag('assets', assets)
"""Register a Jinja2 extension with a Coffin library object. """ from jinja2.ext import Extension from jinja2 import nodes class FooExtension(Extension): tags = set(['foo']) def parse(self, parser): parser.stream.next() return nodes.Const('{foo}') from coffin.template import Library register = Library() register.tag(FooExtension)
""" tags = set(['static']) def parse(self, parser): stream = parser.stream lineno = stream.next().lineno path = parser.parse_expression() call_node = self.call_method('get_statc_url', args=[path]) if stream.next_if('name:as'): var = nodes.Name(stream.expect('name').value, 'store') return nodes.Assign(var, call_node).set_lineno(lineno) else: return nodes.Output([call_node]).set_lineno(lineno) @classmethod def get_statc_url(cls, path): return urljoin(PrefixExtension.get_uri_setting("STATIC_URL"), path) register.tag(GetStaticPrefixExtension) register.tag(GetMediaPrefixExtension) register.tag(StaticExtension) def static(path): return StaticExtension.get_static_url(path)
filters = value warnings.warn('The "filter" option of the {% assets %} ' 'template tag has been renamed to ' '"filters" for consistency reasons.', ImminentDeprecationWarning) # positional arguments are source files elif name is None: files.append(value) else: raise template.TemplateSyntaxError('Unsupported keyword argument "%s"'%name) # capture until closing tag childnodes = parser.parse(("endassets",)) parser.delete_first_token() return AssetsNode(filters, output, files, childnodes) # If Coffin is installed, expose the Jinja2 extension try: from coffin.template import Library as CoffinLibrary except ImportError: register = template.Library() else: register = CoffinLibrary() from webassets.ext.jinja2 import AssetsExtension from django_assets.env import get_env register.tag(AssetsExtension, environment={'assets_environment': get_env()}) # expose the default Django tag register.tag('assets', assets)
Works exactly like Django's own tag. """ tags = ['spaceless'] def parse(self, parser): lineno = parser.stream.next().lineno body = parser.parse_statements(['name:endspaceless'], drop_needle=True) return nodes.CallBlock( self.call_method('_strip_spaces', [], [], None, None), [], [], body).set_lineno(lineno) def _strip_spaces(self, caller=None): from django.utils.html import strip_spaces_between_tags return strip_spaces_between_tags(caller().strip()) # nicer import names load = LoadExtension url = URLExtension with_ = WithExtension cache = CacheExtension spaceless = SpacelessExtension register = Library() register.tag(load) register.tag(url) register.tag(with_) register.tag(cache) register.tag(spaceless)