Esempio n. 1
0
 def _load_lib(lib):
     if not isinstance(lib, CoffinLibrary):
         # If this is only a standard Django library,
         # convert it. This will ensure that Django
         # filters in that library are converted and
         # made available in Jinja.
         lib = CoffinLibrary.from_django(lib)
     extensions.extend(getattr(lib, 'jinja2_extensions', []))
     filters.update(getattr(lib, 'jinja2_filters', {}))
     globals.update(getattr(lib, 'jinja2_globals', {}))
     tests.update(getattr(lib, 'jinja2_tests', {}))
     attrs.update(getattr(lib, 'jinja2_environment_attrs', {}))
Esempio n. 2
0
 def _load_lib(lib):
     if not isinstance(lib, CoffinLibrary):
         # If this is only a standard Django library,
         # convert it. This will ensure that Django
         # filters in that library are converted and
         # made available in Jinja.
         lib = CoffinLibrary.from_django(lib)
     extensions.extend(getattr(lib, 'jinja2_extensions', []))
     filters.update(getattr(lib, 'jinja2_filters', {}))
     globals.update(getattr(lib, 'jinja2_globals', {}))
     tests.update(getattr(lib, 'jinja2_tests', {}))
     attrs.update(getattr(lib, 'jinja2_environment_attrs', {}))
Esempio n. 3
0
    def _get_templatelibs(self):
        """Return an iterable of template ``Library`` instances.

        Since we cannot support the {% load %} tag in Jinja, we have to
        register all libraries globally.
        """
        from django.conf import settings
        from django.template import get_library, InvalidTemplateLibrary

        libs = []
        for a in settings.INSTALLED_APPS:
            try:
                path = __import__(a + '.templatetags', {}, {}, ['__file__']).__file__
                path = os.path.dirname(path)  # we now have the templatetags/ directory
            except ImportError:
                pass
            else:
                for f in os.listdir(path):
                    if f == '__init__.py':
                        continue
                    if f.endswith('.py'):
                        try:
                            # TODO: will need updating when #6587 lands
                            # libs.append(get_library(
                            #     "django.templatetags.%s" % os.path.splitext(f)[0]))
                            l = get_library(os.path.splitext(f)[0])
                            if not isinstance(l, CoffinLibrary):
                                # If this is only a standard Django library,
                                # convert it. This will ensure that Django
                                # filters in that library are converted and
                                # made available in Jinja.
                                l = CoffinLibrary.from_django(l)
                            libs.append(l)

                        except InvalidTemplateLibrary:
                            pass
        return libs
Esempio n. 4
0
import urllib
import hashlib

from django.conf import settings
from django.contrib.sites.models import Site
from django.utils.translation import get_language_from_request, ugettext

if 'coffin' in settings.INSTALLED_APPS:
    from coffin.template import Library
    from jinja2 import Markup as mark_safe
else:
    from django.template import Library
    from django.utils.safestring import mark_safe

register = Library()

if 'coffin' in settings.INSTALLED_APPS:
    register.simple_tag = register.object


def current_site_url():
    """Returns fully qualified URL (no trailing slash) for the current site."""
    protocol = getattr(settings, 'MY_SITE_PROTOCOL', 'https')
    port     = getattr(settings, 'MY_SITE_PORT', '')
    url = '%s://%s' % (protocol, settings.SITE_DOMAIN)
    if port:
        url += ':%s' % port
    return url

@register.simple_tag
Esempio n. 5
0
    return ""


@contextfilter
def context(context, value):
    return ""


def multiarg(value, arg1, arg2):
    return ""


def jinja_forced(value):
    return ""


def django_jinja_forced(value):
    # a django filter that returns a django-safestring. It will *only*
    # be added to jinja, and coffin will hopefully ensure the string
    # stays safe.
    from django.utils.safestring import mark_safe
    return mark_safe(value)


from coffin.template import Library
register = Library()
register.filter('environment', environment)
register.filter('context', context)
register.filter('multiarg', multiarg)
register.filter('jinja_forced', jinja_forced, jinja2_only=True)
register.filter('django_jinja_forced', django_jinja_forced, jinja2_only=True)
Esempio n. 6
0
from django import template as django_template
from jinja2 import nodes, contextfunction, ext
from coffin.template import Library, Template

register = Library()


class JinjaInclude(django_template.Node):

    def __init__(self, filename):
        self.filename = filename

    def render(self, context):
        from coffin import shortcuts
        return shortcuts.render_to_string(self.filename, context)


class Jinja(django_template.Node):

    def __init__(self, template):
        self.template = template

    def render(self, context):
        return self.template.render(context)


class DjangoNoop(django_template.Node):

    def render(self, context):
        return ''
Esempio n. 7
0
from django.conf import settings

if 'coffin' in settings.INSTALLED_APPS:
    from jinja2 import nodes, Markup
    from jinja2.ext import Extension
    from coffin.template import Library
    
    from guide.templatetags.guide_tags import AddGuide, render_guides as origin_render_guides

    register = Library()

    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()
Esempio n. 8
0
"""Coffin automatically makes Django's builtin filters available in Jinja2,
through an interop-layer.

However, Jinja 2 provides room to improve the syntax of some of the
filters. Those can be overridden here.

TODO: Most of the filters in here need to be updated for autoescaping.
"""

from coffin.template import Library
from jinja2.runtime import Undefined
# from jinja2 import Markup
from jinja2 import filters

register = Library()

def url(view_name, *args, **kwargs):
    """This is an alternative to the {% url %} tag. It comes from a time
    before Coffin had a port of the tag.
    """
    from coffin.template.defaulttags import url
    return url._reverse(view_name, args, kwargs)
register.jinja2_filter(url, jinja2_only=True)
register.object(url)

@register.jinja2_filter(jinja2_only=True)
def timesince(value, *arg):
    if value is None or isinstance(value, Undefined):
        return u''
    from django.utils.timesince import timesince
    return timesince(value, *arg)
Esempio n. 9
0
    """

    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)
Esempio n. 10
0
    """

    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)
Esempio n. 11
0
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)
Esempio n. 12
0
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)
Esempio n. 13
0
"""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)
# coding=utf8
from urlparse import urljoin
from coffin.template import Library
from jinja2.ext import Extension
from jinja2 import nodes
from django.utils.encoding import iri_to_uri
from django.conf import settings
from models import StaticFile


register = Library()


class PrefixExtension(Extension):

    def parse(self, parser):
        stream = parser.stream
        lineno = stream.next().lineno

        call_node = self.call_method('render')

        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)

    def render(self, name):
        raise NotImplementedError()

    @classmethod
Esempio n. 15
0
"""Register a portable filter with a Coffin library object.
"""

def foo(value):
    return "{foo}"

from coffin.template import Library
register = Library()
register.filter('foo', foo)
Esempio n. 16
0
from coffin.template import Library
from django_minify import minify
from django_minify.conf import settings
from django_minify.templatetags import combine
from jinja2 import Markup, contextfunction, ext, nodes

register = Library()


class MinifyExtension(ext.Extension):
    tags = None
    template = None
    extension = None
    Minifier = None
    
    def __init__(self, *args, **kwargs):
        super(MinifyExtension, self).__init__(*args, **kwargs)
        assert self.tags, 'Extensions should be linked to one or more tags'
        assert self.template, ('MinifyExtensions require a template to '
            'render (even "%s" works)')
        assert self.extension, ('An extension for the output files is '
            'required')
        assert self.Minifier, 'The extension requires a minifying module'

    def parse(self, parser):
        lineno = parser.stream.next().lineno
        includes = parser.parse_statements(['name:%s' % self.tags[-1]],
            drop_needle=True)

        return nodes.CallBlock(
            self.call_method('_render', [], [], None, None),
Esempio n. 17
0
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_)
Esempio n. 18
0
try:
    from urllib.parse import urljoin
except ImportError:     # Python 2
    from urlparse import urljoin

from coffin.template import Library
from jinja2.ext import Extension
from jinja2 import nodes
from django.utils.encoding import iri_to_uri


register = Library()


class PrefixExtension(Extension):

    def parse(self, parser):
        stream = parser.stream
        lineno = stream.next().lineno

        call_node = self.call_method('render')

        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)

    def render(self, name):
        raise NotImplementedError()
Esempio n. 19
0
"""Coffin automatically makes Django's builtin filters available in Jinja2,
through an interop-layer.

However, Jinja 2 provides room to improve the syntax of some of the
filters. Those can be overridden here.

TODO: Most of the filters in here need to be updated for autoescaping.
"""

from coffin.template import Library
from jinja2.runtime import Undefined
# from jinja2 import Markup
from jinja2 import filters

register = Library()


def url(view_name, *args, **kwargs):
    """This is an alternative to the {% url %} tag. It comes from a time
    before Coffin had a port of the tag.
    """
    from coffin.template.defaulttags import url
    return url._reverse(view_name, args, kwargs)


register.jinja2_filter(url, jinja2_only=True)
register.object(url)


@register.jinja2_filter(jinja2_only=True)
def timesince(value, *arg):
Esempio n. 20
0

def jinja_safe_output(value):
    return Markup(value)

def django_safe_output(value):
    return mark_safe(value)

def unsafe_output(value):
    return unicode(value)


def django_raw_output(value):
    return value

def django_escape_output(value):
    # Make sure the value is converted to unicode first, because otherwise,
    # if it is already SafeData (for example, when coming from the template
    # code), then mark_for_escaping would do nothing. We want to guarantee
    # a EscapeData return value in this filter though.
    return mark_for_escaping(unicode(value))


from coffin.template import Library
register = Library()
register.filter('needing_autoescape', needing_autoescape)
register.filter('jinja_safe_output', jinja_safe_output)
register.filter('django_safe_output', django_safe_output)
register.filter('django_raw_output', django_raw_output)
register.filter('unsafe_output', unsafe_output)
register.filter('django_escape_output', django_escape_output)
Esempio n. 21
0
from coffin.template import Library
from django.contrib.staticfiles.storage import staticfiles_storage
from coffin.templatetags.static import StaticExtension as CoffinStaticExtension


register = Library()


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))
Esempio n. 22
0
"""Register a Jinja2 global object with a Coffin library object.
"""

def hello_func(name):
    return u"Hello %s" % name

from coffin.template import Library
register = Library()
register.object('hello', hello_func)
Esempio n. 23
0
"""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'})
Esempio n. 24
0
"""Makes the template filters from the ``django.contrib.markup`` app
available to both the Jinja2 and Django engines.

In other words, adding ``coffin.contrib.markup`` to your INSTALLED_APPS
setting will enable the markup filters not only through Coffin, but
also through the default Django template system.
"""

from coffin.template import Library as CoffinLibrary
from django.contrib.markup.templatetags.markup import register

# Convert Django's Library into a Coffin Library object, which will
# make sure the filters are correctly ported to Jinja2.
register = CoffinLibrary.from_django(register)
Esempio n. 25
0
from jinja2 import environmentfilter, contextfilter

@environmentfilter
def environment(environment, value):
    return ""

@contextfilter
def context(context, value):
    return ""

def multiarg(value, arg1, arg2):
    return ""

def jinja_forced(value):
    return ""

def django_jinja_forced(value):
    # a django filter that returns a django-safestring. It will *only*
    # be added to jinja, and coffin will hopefully ensure the string
    # stays safe.
    from django.utils.safestring import mark_safe
    return mark_safe(value)


from coffin.template import Library
register = Library()
register.filter('environment', environment)
register.filter('context', context)
register.filter('multiarg', multiarg)
register.filter('jinja_forced', jinja_forced, jinja2_only=True)
register.filter('django_jinja_forced', django_jinja_forced, jinja2_only=True)
Esempio n. 26
0
    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)

Esempio n. 27
0
    return Markup(value)


def django_safe_output(value):
    return mark_safe(value)


def unsafe_output(value):
    return unicode(value)


def django_raw_output(value):
    return value


def django_escape_output(value):
    # Make sure the value is converted to unicode first, because otherwise,
    # if it is already SafeData (for example, when coming from the template
    # code), then mark_for_escaping would do nothing. We want to guarantee
    # a EscapeData return value in this filter though.
    return mark_for_escaping(unicode(value))


from coffin.template import Library
register = Library()
register.filter('needing_autoescape', needing_autoescape)
register.filter('jinja_safe_output', jinja_safe_output)
register.filter('django_safe_output', django_safe_output)
register.filter('django_raw_output', django_raw_output)
register.filter('unsafe_output', unsafe_output)
register.filter('django_escape_output', django_escape_output)
Esempio n. 28
0
"""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)
Esempio n. 29
0
        if self.use_pdb:
            pdb_with_context(context)
        else:
            setup_readline_history()
            run_shell(context)
        return ''

@register.tag
def repl(parser, token):
    use_pdb = False
    bits = token.contents.split()
    if len(bits) > 1:
        if bits[1] == 'pdb':
            use_pdb = True
        else:
            raise TemplateSyntaxError('The second argument to the "repl" tag, if present, must be "pdb".')
    return REPLNode(use_pdb)


try:
    from coffin.template import Library as CoffinLibrary
    import coffin.common
except ImportError:
    pass
else:
    # We could simply create a Coffin library in the first place,
    # of course, but this allows us to more easily maintain this
    # change as a fork.
    from template_repl.jinja2_ext import REPLExtension
    register = CoffinLibrary.from_django(register)
    register.tag(REPLExtension)
Esempio n. 30
0
            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)
Esempio n. 31
0
        # 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)
Esempio n. 32
0
"""Register a Jinja2 global object with a Coffin library object.
"""


def hello_func(name):
    return u"Hello %s" % name


from coffin.template import Library
register = Library()
register.object('hello', hello_func)
Esempio n. 33
0
try:
    from urllib.parse import urljoin
except ImportError:  # Python 2
    from urlparse import urljoin

from coffin.template import Library
from jinja2.ext import Extension
from jinja2 import nodes
from django.utils.encoding import iri_to_uri

register = Library()


class PrefixExtension(Extension):
    def parse(self, parser):
        stream = parser.stream
        lineno = stream.next().lineno

        call_node = self.call_method('render')

        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)

    def render(self, name):
        raise NotImplementedError()

    @classmethod
    def get_uri_setting(cls, name):
Esempio n. 34
0
import math
import urllib
from coffin.template import Library
register = Library()


@register.object(name='widthratio')
def widthratio(min=0, max=100, range=100):
    return int(math.ceil(float(float(min) / float(max) * int(range))))


@register.object(name='query')
def query_string(**kwargs):
    query = urllib.urlencode(kwargs)
    return '?%s' % (query if kwargs else '')


@register.filter(name='markdown')
def parse_markdown(value, format="html5"):
    import markdown
    return markdown.markdown(value, safe_mode='escape', output_format=format)
Esempio n. 35
0
from coffin.template import Library

register = Library()

register.object(ord)
register.object(chr)
Esempio n. 36
0
import urllib
import hashlib

from django.conf import settings
from django.contrib.sites.models import Site
from django.utils.translation import get_language_from_request, ugettext

if 'coffin' in settings.INSTALLED_APPS:
    from coffin.template import Library
    from jinja2 import Markup as mark_safe
else:
    from django.template import Library
    from django.utils.safestring import mark_safe

register = Library()

if 'coffin' in settings.INSTALLED_APPS:
    register.simple_tag = register.object


def current_site_url():
    """Returns fully qualified URL (no trailing slash) for the current site."""
    protocol = getattr(settings, 'MY_SITE_PROTOCOL', 'https')
    port = getattr(settings, 'MY_SITE_PORT', '')
    url = '%s://%s' % (protocol, settings.SITE_DOMAIN)
    if port:
        url += ':%s' % port
    return url

Esempio n. 37
0
                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)
Esempio n. 38
0
from coffin.template import Library
from django_minify import minify
from django_minify.conf import settings
from django_minify.templatetags import combine
from jinja2 import Markup, contextfunction, ext, nodes

register = Library()

def urljoin(*args):
    """
    Joins given arguments into a url. Trailing but not leading slashes are
    stripped for each argument.
    """

    return "/".join(map(lambda x: str(x).rstrip('/'), args))

class MinifyExtension(ext.Extension):
    tags = None
    template = None
    extension = None
    Minifier = None
    
    def __init__(self, *args, **kwargs):
        super(MinifyExtension, self).__init__(*args, **kwargs)
        assert self.tags, 'Extensions should be linked to one or more tags'
        assert self.template, ('MinifyExtensions require a template to '
            'render (even "%s" works)')
        assert self.extension, ('An extension for the output files is '
            'required')
        assert self.Minifier, 'The extension requires a minifying module'
Esempio n. 39
0
"""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)