9b67c25b39099ddf64ee5b0b422c2c92478d8c91
[django-ssify.git] / ssify / decorators.py
1 import functools
2 from inspect import getargspec
3 import warnings
4 from django.template.base import parse_bits
5 from django.utils.translation import get_language, activate
6 from .store import cache_include
7 from . import exceptions
8 from .variables import SsiVariable
9
10
11 def ssi_included(view=None, use_lang=True, get_ssi_vars=None):
12     """
13     Marks a view to be used as a snippet to be included with SSI.
14
15     If use_lang is True (which is default), the URL pattern for such
16     a view must provide a keyword argument named 'lang' for language.
17     SSI included views don't use language or content negotiation, so
18     everything they need to know has to be included in the URL.
19
20     get_ssi_vars should be a callable which takes the view's arguments
21     and returns the names of SSI variables it uses.
22
23     """
24     def dec(view):
25         @functools.wraps(view)
26         def new_view(request, *args, **kwargs):
27             if use_lang:
28                 try:
29                     lang = kwargs.pop('lang')
30                 except KeyError:
31                     raise exceptions.NoLangFieldError(request)
32                 current_lang = get_language()
33                 activate(lang)
34             response = view(request, *args, **kwargs)
35             if use_lang:
36                 activate(current_lang)
37             if response.status_code == 200:
38                 request._cache_update_cache = False
39
40                 def _check_included_vars(response):
41                     used_vars = request.ssi_vars_needed
42                     if get_ssi_vars:
43                         # Remove the ssi vars that should be provided
44                         # by the including view.
45                         pass_vars = set(get_ssi_vars(*args, **kwargs))
46
47                         for var in pass_vars:
48                             if not isinstance(var, SsiVariable):
49                                 var = SsiVariable(*var)
50                             try:
51                                 del used_vars[var.name]
52                             except KeyError:
53                                 warnings.warn(
54                                     exceptions.UnusedSsiVarsWarning(
55                                         request, var))
56                     if used_vars:
57                         raise exceptions.UndeclaredSsiVarsError(
58                             request, used_vars)
59                     request.ssi_vars_needed = {}
60
61                     # Don't use default django response caching for this view,
62                     # just save the contents instead.
63                     cache_include(request.path, response.content)
64
65                 if hasattr(response, 'render') and callable(response.render):
66                     response.add_post_render_callback(_check_included_vars)
67                 else:
68                     _check_included_vars(response)
69
70             return response
71
72         # Remember get_ssi_vars so that in can be computed from args/kwargs
73         # by including view.
74         new_view.get_ssi_vars = get_ssi_vars
75         return new_view
76     return dec(view) if view else dec
77
78
79 def ssi_variable(register, vary=None, name=None):
80     # Cache control?
81     def dec(func):
82         # Find own path.
83         function_name = (name or
84                          getattr(func, '_decorated_function', func).__name__)
85         lib_name = func.__module__.rsplit('.', 1)[-1]
86         tagpath = "%s.%s" % (lib_name, function_name)
87         # Make sure the function takes request parameter.
88         params, varargs, varkw, defaults = getargspec(func)
89         assert params and params[0] == 'request', '%s is decorated with '\
90             'request_info_tag, so it must take `request` for '\
91             'its first argument.' % (tagpath)
92
93         @register.tag(name=function_name)
94         def _ssi_var_tag(parser, token):
95             """
96             Creates a SSI variable reference for a request-dependent info.
97
98             Use as:
99                 {% ri_tag args... %}
100             or:
101                 {% ri_tag args... as variable %}
102                 {{ variable.if }}
103                     {{ variable }}, or
104                     {% ssi_include 'some-snippet' variable %}
105                 {{ variable.else }}
106                     Default text
107                 {{ variable.endif }}
108
109             """
110             bits = token.split_contents()[1:]
111
112             # Is it the 'as' form?
113             if len(bits) >= 2 and bits[-2] == 'as':
114                 asvar = bits[-1]
115                 bits = bits[:-2]
116             else:
117                 asvar = None
118
119             # Parse the arguments like Django's generic tags do.
120             args, kwargs = parse_bits(parser, bits,
121                                       ['context'] + params[1:], varargs, varkw,
122                                       defaults, takes_context=True,
123                                       name=function_name)
124             return SsiVariableNode(tagpath, args, kwargs, vary, asvar)
125         _ssi_var_tag.get_value = func
126         #return _ssi_var_tag
127         return func
128
129     return dec
130
131
132 from .variables import SsiVariableNode