668bb51475c79354b99a1b1eb13ab4784b85ce30
[django-ssify.git] / ssify / variables.py
1 # -*- coding: utf-8 -*-
2 # This file is part of django-ssify, licensed under GNU Affero GPLv3 or later.
3 # Copyright © Fundacja Nowoczesna Polska. See README.md for more information.
4 #
5 """
6 Utilities for defining SSI variables.
7
8 SSI variables are a way of providing values that need to be computed
9 at request time to the prerendered templates.
10
11 """
12 from __future__ import unicode_literals
13 from hashlib import md5
14 from django import template
15 from django.utils.encoding import force_text, python_2_unicode_compatible
16 from django.utils.functional import Promise
17 from django.utils.safestring import mark_safe
18 from .exceptions import SsiVarsDependencyCycleError
19
20
21 @python_2_unicode_compatible
22 class SsiVariable(object):
23     """
24     Represents a variable computed by a template tag with given arguments.
25
26     Instance of this class is returned from any template tag created
27     with `decorators.ssi_variable` decorator. If renders as SSI echo
28     statement, but you can also use it as an argument to {% ssi_include %},
29     to other ssi_variable, or create SSI if statements by using
30     its `if`, `else`, `endif` properties.
31
32     Variable's name, as used in SSI statements, is a hash of its definition,
33     so the user never has to deal with it directly.
34
35     """
36     def __init__(self, tagpath=None, args=None, kwargs=None, name=None):
37         self.tagpath = tagpath
38         self.args = list(args or [])
39         self.kwargs = kwargs or {}
40         self._name = name
41
42     @property
43     def name(self):
44         """Variable name is a hash of its definition."""
45         if self._name is None:
46             self._name = 'v' + md5(json_encode(self.definition).encode('ascii')).hexdigest()
47         return self._name
48
49     def rehash(self):
50         """
51         Sometimes there's a need to reset the variable name.
52
53         Typically, this is the case after finding real values for
54         variables passed as arguments to {% ssi_include %}.
55         """
56         self._name = None
57         return self.name
58
59     @property
60     def definition(self):
61         """Variable is defined by path to template tag and its arguments."""
62         if self.kwargs:
63             return self.tagpath, self.args, self.kwargs
64         elif self.args:
65             return self.tagpath, self.args
66         else:
67             return self.tagpath,
68
69     def __repr__(self):
70         return "SsiVariable(%s: %s)" % (self.name, repr(self.definition))
71
72     def get_value(self, request):
73         """Computes the real value of the variable, using the request."""
74         taglib, tagname = self.tagpath.rsplit('.', 1)
75         return template.get_library(taglib).tags[tagname].get_value(
76             request, *self.args, **self.kwargs)
77
78     def __str__(self):
79         return mark_safe("<!--#echo var='%s' encoding='none'-->" % self.name)
80
81     def as_var(self):
82         """Returns the form that can be used in SSI include's URL."""
83         return '${%s}' % self.name
84
85 # If-else-endif properties for use in templates.
86 setattr(SsiVariable, 'if',
87         lambda self: mark_safe("<!--#if expr='${%s}'-->" % self.name))
88 setattr(SsiVariable, 'else',
89         staticmethod(lambda: mark_safe("<!--#else-->")))
90 setattr(SsiVariable, 'endif',
91         staticmethod(lambda: mark_safe('<!--#endif-->')))
92
93
94 class SsiExpect(object):
95     """This class says: I want the real value of this variable here."""
96     def __init__(self, name):
97         self.name = name
98     def __repr__(self):
99         return "SsiExpect(%s)" % (self.name,)
100
101
102 def ssi_expect(var, type_):
103     """
104     Helper function for defining get_ssi_vars on ssi_included views.
105
106     The view needs a way of calculating all the needed variables from
107     the view args. But the args are probably the wrong type
108     (typically, str instead of int) or even are SsiVariables, not
109     resolved until request time.
110
111     This function provides a way to expect a real value of the needed type.
112
113     """
114     if isinstance(var, SsiVariable):
115         return SsiExpect(var.name)
116     else:
117         return type_(var)
118
119
120 class SsiVariableNode(template.Node):
121     """ Node for the SsiVariable tags. """
122     def __init__(self, tagpath, args, kwargs, patch_response=None, asvar=None):
123         self.tagpath = tagpath
124         self.args = args
125         self.kwargs = kwargs
126         self.patch_response = patch_response
127         self.asvar = asvar
128
129     def __repr__(self):
130         return "<SsiVariableNode>"
131
132     def render(self, context):
133         """Renders the tag as SSI echo or sets the context variable."""
134         resolved_args = [var.resolve(context) for var in self.args]
135         resolved_kwargs = dict((k, v.resolve(context))
136                                for k, v in self.kwargs.items())
137         var = SsiVariable(self.tagpath, resolved_args, resolved_kwargs)
138
139         request = context['request']
140         request.ssi_vars_needed[var.name] = var
141         if self.patch_response:
142             request.ssi_patch_response.extend(self.patch_response)
143
144         if self.asvar:
145             context.dicts[0][self.asvar] = var
146             return ''
147         else:
148             return var
149
150
151 def ssi_set_statement(var, value):
152     """Generates an SSI set statement for a variable."""
153     if isinstance(value, Promise):
154         # Yes, this is quite brutal. But we need to know
155         # the real value now, we don't know the type,
156         # and we only want to evaluate the lazy function once.
157         value = value._proxy____cast()
158     if value is False or value is None:
159         value = ''
160     return "<!--#set var='%s' value='%s'-->" % (
161         var,
162         force_text(value).replace('\\', '\\\\').replace("'", "\\'"))
163
164
165 def provide_vars(request, ssi_vars):
166     """
167     Provides all the SSI set statements for ssi_vars variables.
168
169     The main purpose of this function is to by called by SsifyMiddleware.
170     """
171     def resolve_expects(var):
172         if not hasattr(var, 'hash_dirty'):
173             var.hash_dirty = False
174
175         for i, arg in enumerate(var.args):
176             if isinstance(arg, SsiExpect):
177                 var.args[i] = resolved[arg.name]
178                 var.hash_dirty = True
179         for k, arg in var.kwargs.items():
180             if isinstance(arg, SsiExpect):
181                 var.kwargs[k] = resolved[arg.name]
182                 var.hash_dirty = True
183
184         for arg in var.args + list(var.kwargs.values()):
185             if isinstance(arg, SsiVariable):
186                 var.hash_dirty = resolve_expects(arg) or var.hash_dirty
187
188         hash_dirty = var.hash_dirty
189         if var.hash_dirty:
190             # Rehash after calculating the SsiExpects with real
191             # values, because that's what the included views expect.
192             var.rehash()
193             var.hash_dirty = False
194
195         return hash_dirty
196
197     def resolve_args(var):
198         kwargs = {}
199         for k, arg in var.kwargs.items():
200             kwargs[k] = resolved[arg.name] if isinstance(arg, SsiVariable) else arg
201         new_var = SsiVariable(var.tagpath,
202             [resolved[arg.name] if isinstance(arg, SsiVariable) else arg for arg in var.args],
203             kwargs)
204         return new_var
205
206     resolved = {}
207     queue = list(ssi_vars.values())
208     
209     unresolved_streak = 0
210     while queue:
211         var = queue.pop(0)
212         try:
213             resolve_expects(var)
214             rv = resolve_args(var)
215         except KeyError as e:
216             queue.append(var)
217             unresolved_streak += 1
218             if unresolved_streak > len(queue):
219                 raise SsiVarsDependencyCycleError(request, queue, resolved)
220             continue
221
222         resolved[var.name] = rv.get_value(request)
223         unresolved_streak = 0
224
225     output = "".join(ssi_set_statement(var, value)
226                       for (var, value) in resolved.items()
227                       ).encode('utf-8')
228     return output
229
230
231 from .serializers import json_encode