Reworked inlinecompile templatetag to fix Django 2.0 compatibility.

Author: sir-sigurd

static_precompiler/templatetags/base.py

@@ -6,8 +6,6 @@
 
 from static_precompiler import settings, utils
 
-from . import base
-
 register = django.template.Library()
 
 
@@ -35,24 +33,50 @@ def compile_tag(source_path, compiler=None):
     return compiled
 
 
-@base.container_tag(register)
-def inlinecompile(nodelist, context, compiler):
-    source = nodelist.render(context)
+class InlineCompileNode(django.template.Node):
+    def __init__(self, nodelist, compiler):
+        self.nodelist = nodelist
+        self.compiler = compiler
+
+    def render(self, context):
+        source = self.nodelist.render(context)
+
+        if self.compiler[0] == self.compiler[-1] and self.compiler[0] in ('"', "'"):
+            compiler = self.compiler[1:-1]
+        else:
+            compiler = django.template.Variable(self.compiler).resolve(context)
+
+        if isinstance(compiler, six.string_types):
+            compiler = utils.get_compiler_by_name(compiler)
+
+        if settings.USE_CACHE:
+            cache_key = utils.get_cache_key("{0}.{1}".format(
+                compiler.__class__.__name__,
+                utils.get_hexdigest(source)
+            ))
+            cache = utils.get_cache()
+            cached = cache.get(cache_key, None)
+            if cached is not None:
+                return cached
+            output = compiler.compile_source(source)
+            cache.set(cache_key, output, settings.CACHE_TIMEOUT)
+            return output
 
-    if isinstance(compiler, six.string_types):
-        compiler = utils.get_compiler_by_name(compiler)
+        return compiler.compile_source(source)
 
-    if settings.USE_CACHE:
-        cache_key = utils.get_cache_key("{0}.{1}".format(
-            compiler.__class__.__name__,
-            utils.get_hexdigest(source)
-        ))
-        cache = utils.get_cache()
-        cached = cache.get(cache_key, None)
-        if cached is not None:
-            return cached
-        output = compiler.compile_source(source)
-        cache.set(cache_key, output, settings.CACHE_TIMEOUT)
-        return output
 
-    return compiler.compile_source(source)
+@register.tag
+def inlinecompile(parser, token):
+    bits = token.split_contents()
+    tag_name = bits[0]
+    try:
+        compiler, = bits[1:]
+    except ValueError:
+        raise django.template.TemplateSyntaxError(
+            '%r tag requires exactly one argument.' % tag_name
+        )
+    if compiler.startswith('compiler='):
+        compiler = compiler[len('compiler='):]
+    nodelist = parser.parse(('end' + tag_name,))
+    parser.delete_first_token()
+    return InlineCompileNode(nodelist, compiler)

static_precompiler/templatetags/compile_static.py

@@ -31,3 +31,5 @@
     "static_precompiler",
 )
 MTIME_DELAY = 2
+
+STATIC_PRECOMPILER_USE_CACHE = False

static_precompiler/tests/django_settings.py

@@ -28,3 +28,12 @@ def test_inlinecompile_tag(monkeypatch):
 
     assert get_compiler_by_name.calls == [pretend.call("sass")]
     assert compiler.compile_source.calls == [pretend.call("source")]
+
+
+def test_inlinecompile_tag_compiler_as_variable(monkeypatch):
+    compiler = pretend.stub(compile_source=pretend.call_recorder(lambda *args: 'compiled'))
+    template = django.template.Template(
+        "{% load compile_static %}{% inlinecompile compiler %}source{% endinlinecompile %}"
+    )
+    assert template.render(django.template.Context({'compiler': compiler})) == 'compiled'
+    assert compiler.compile_source.calls == [pretend.call('source')]