Relative paths for Django template tags 'extends' and 'include'.

"""
Library for enable relative pathes in django template tags
'extends' and 'include'

(C) 2016 by Vitaly Bogomolov [email protected]
Origin: https://github.com/vb64/django.templates.relative.path
"""

import posixpath

from django import template
from django.conf import settings
from django.template.base import Template as TemplateParent
from django.template.base import (Lexer, Parser, StringOrigin,
                                  TemplateEncodingError, TemplateSyntaxError,
                                  token_kwargs)
from django.template.loader_tags import ExtendsNode as ExtendsNodeParent
from django.template.loader_tags import IncludeNode
from django.template.loaders import app_directories as ad
from django.template.loaders import filesystem as fs
from django.utils.encoding import smart_unicode

# django 1.9
try:
    from django.template import (
        TemplateDoesNotExist,
        Template as Template19parent,
    )
    from django.utils.inspect import func_supports_parameter
    from django.template.base import DebugLexer as DebugLexer19
    from django.template.utils import get_app_template_dirs
except:
    pass

################################################
# template loaders
################################################


def compile_string(template_string, origin, name):
    """
    Set template name to Parser instance
    """
    if settings.TEMPLATE_DEBUG:
        from django.template.debug import DebugLexer, DebugParser
        lexer_class, parser_class = DebugLexer, DebugParser
    else:
        lexer_class, parser_class = Lexer, Parser
    lexer = lexer_class(template_string, origin)
    parser = parser_class(lexer.tokenize())
    parser.template_name = name
    return parser.parse()


class Template(TemplateParent):
    """
    Pass template name to Parser
    """

    def __init__(self, template_string, origin=None, name=None, engine=None):
        try:
            template_string = smart_unicode(template_string)
        except UnicodeDecodeError:
            raise TemplateEncodingError("Templates can only be constructed "
                                        "from unicode or UTF-8 strings.")
        if settings.TEMPLATE_DEBUG and origin is None:
            origin = StringOrigin(template_string)
        self.nodelist = compile_string(template_string, origin, name)
        self.name = name
        self.origin = origin

        # !!! ATTENTION !!!
        # always use default engine for render
        try:
            from django.template.engine import Engine
            self.engine = Engine.get_default()
        except Exception:
            self.engine = None


class FileSystem(fs.Loader):
    """
    Use modified Template class
    """
    is_usable = True

    def load_template(self, template_name, template_dirs=None):
        """
        Use modified Template class and pass template name
        """
        source, origin = self.load_template_source(
            template_name,
            template_dirs
        )

        template = Template(
            source,
            name=template_name
        )

        return template, origin


class AppDirectories(ad.Loader):
    """
    Use modified Template class
    """
    is_usable = True

    def load_template(self, template_name, template_dirs=None):
        """
        Use modified Template class and pass template name
        """
        source, origin = self.load_template_source(
            template_name, template_dirs
        )
        template = Template(source, name=template_name)
        return template, origin


class Template19(Template19parent):
    """
    Pass template name to Parser into Django 1.9
    """

    def compile_nodelist(self):
        """
        Pass template name to parser instance
        """

        if self.engine.debug:
            lexer = DebugLexer19(self.source)
        else:
            lexer = Lexer(self.source)

        tokens = lexer.tokenize()
        parser = Parser(
            tokens,
            self.engine.template_libraries,
            self.engine.template_builtins,
        )

        parser.template_name = self.origin.template_name

        try:
            return parser.parse()
        except Exception as e:
            if self.engine.debug:
                e.template_debug = self.get_exception_info(e, e.token)
            raise


class FileSystem19(fs.Loader):
    """
    Use modified Template19 class
    """

    def get_template(self, template_name, template_dirs=None, skip=None):
        """
        Use modified Template19 class and
        pass template name to instance
        """
        tried = []

        args = [template_name]
        if func_supports_parameter(self.get_template_sources, 'template_dirs'):
            args.append(template_dirs)

        for origin in self.get_template_sources(*args):
            if skip is not None and origin in skip:
                tried.append((origin, 'Skipped'))
                continue

            try:
                contents = self.get_contents(origin)
            except TemplateDoesNotExist:
                tried.append((origin, 'Source does not exist'))
                continue
            else:
                return Template19(
                    contents, origin, origin.template_name, self.engine,
                )

        raise TemplateDoesNotExist(template_name, tried=tried)


class AppDirectories19(FileSystem19):
    """
    Use modified Template19 class
    """

    def get_dirs(self):
        """
        Same as core function
        """
        return get_app_template_dirs('templates')

################################################
# template tags 'extends' and 'include'
################################################

register = template.Library()


class ExtendsNode(ExtendsNodeParent):
    """
    !!! ATTENTION !!!
    it disable rule, that 'extends' must be first tag in template
    this need for first {% load relative_path %} tag
    """
    must_be_first = False


def construct_relative_path(name, relative_name):
    """
    Construct new path from saved into parser instance name and given
    relative path in extends/include handlers with posixpath functions,
    then handle new path by standard extends/include rules.
    """

    if not relative_name.startswith('"./'):
        # argument is variable or literal, that not contain relative path
        return relative_name

    new_name = posixpath.normpath(
        posixpath.join(
            posixpath.dirname(name.lstrip('/')),
            relative_name.strip('"')
        )
    )

    if new_name.startswith('../'):
        raise TemplateSyntaxError(
            "Relative name '%s' have more parent folders, then given template name '%s'"
            % (relative_name, name)
        )

    if name.lstrip('/') == new_name:
        raise TemplateSyntaxError(
            "Circular dependencies: relative path '%s' was translated to template name '%s'"
            % (relative_name, name)
        )

    return '"%s"' % new_name


@register.tag('extends')
def do_extends(parser, token):
    """
    Same as core function, with construct_relative_path call
    """
    bits = token.split_contents()
    if len(bits) != 2:
        raise TemplateSyntaxError("'%s' takes one argument" % bits[0])

    bits[1] = construct_relative_path(parser.template_name, bits[1])
    parent_name = parser.compile_filter(bits[1])
    nodelist = parser.parse()
    if nodelist.get_nodes_by_type(ExtendsNode):
        raise TemplateSyntaxError(
            "'%s' cannot appear more than once in the same template"
            % bits[0]
            )
    return ExtendsNode(nodelist, parent_name)


@register.tag('include')
def do_include(parser, token):
    """
    Same as core function, with construct_relative_path call
    """
    bits = token.split_contents()
    if len(bits) < 2:
        raise TemplateSyntaxError(
            "%r tag takes at least one argument: "
            "the name of the template to be included."
            % bits[0]
        )
    options = {}
    remaining_bits = bits[2:]
    while remaining_bits:
        option = remaining_bits.pop(0)
        if option in options:
            raise TemplateSyntaxError('The %r option was specified more '
                                      'than once.' % option)
        if option == 'with':
            value = token_kwargs(remaining_bits, parser, support_legacy=False)
            if not value:
                raise TemplateSyntaxError('"with" in %r tag needs at least '
                                          'one keyword argument.' % bits[0])
        elif option == 'only':
            value = True
        else:
            raise TemplateSyntaxError('Unknown argument for %r tag: %r.' %
                                      (bits[0], option))
        options[option] = value
    isolated_context = options.get('only', False)
    namemap = options.get('with', {})
    bits[1] = construct_relative_path(parser.template_name, bits[1])

    return IncludeNode(parser.compile_filter(bits[1]), extra_context=namemap,
                       isolated_context=isolated_context)