Armin Ronacher | e791c2a | 2008-04-07 18:39:54 +0200 | [diff] [blame] | 1 | # -*- coding: utf-8 -*- |
| 2 | """ |
| 3 | jinja2.runtime |
| 4 | ~~~~~~~~~~~~~~ |
| 5 | |
| 6 | Runtime helpers. |
| 7 | |
| 8 | :copyright: Copyright 2008 by Armin Ronacher. |
| 9 | :license: GNU GPL. |
| 10 | """ |
Armin Ronacher | 4f7d2d5 | 2008-04-22 10:40:26 +0200 | [diff] [blame] | 11 | from types import FunctionType |
Armin Ronacher | d134231 | 2008-04-28 12:20:12 +0200 | [diff] [blame] | 12 | from itertools import chain, imap |
| 13 | from jinja2.utils import Markup, partial, soft_unicode, escape |
| 14 | from jinja2.exceptions import UndefinedError, TemplateRuntimeError |
Armin Ronacher | e791c2a | 2008-04-07 18:39:54 +0200 | [diff] [blame] | 15 | |
| 16 | |
Armin Ronacher | 2feed1d | 2008-04-26 16:26:52 +0200 | [diff] [blame] | 17 | # these variables are exported to the template runtime |
Armin Ronacher | c9705c2 | 2008-04-27 21:28:03 +0200 | [diff] [blame] | 18 | __all__ = ['LoopContext', 'TemplateContext', 'TemplateReference', 'Macro', |
Armin Ronacher | d134231 | 2008-04-28 12:20:12 +0200 | [diff] [blame] | 19 | 'TemplateRuntimeError', 'Markup', 'missing', 'concat', 'escape', |
| 20 | 'markup_join', 'unicode_join'] |
Armin Ronacher | 0611e49 | 2008-04-25 23:44:14 +0200 | [diff] [blame] | 21 | |
| 22 | |
| 23 | # special singleton representing missing values for the runtime |
Armin Ronacher | 32a910f | 2008-04-26 23:21:03 +0200 | [diff] [blame] | 24 | missing = type('MissingType', (), {'__repr__': lambda x: 'missing'})() |
Armin Ronacher | 8edbe49 | 2008-04-10 20:43:43 +0200 | [diff] [blame] | 25 | |
| 26 | |
Armin Ronacher | de6bf71 | 2008-04-26 01:44:14 +0200 | [diff] [blame] | 27 | # concatenate a list of strings and convert them to unicode. |
| 28 | concat = u''.join |
| 29 | |
| 30 | |
Armin Ronacher | d134231 | 2008-04-28 12:20:12 +0200 | [diff] [blame] | 31 | def markup_join(*args): |
| 32 | """Concatenation that escapes if necessary and converts to unicode.""" |
| 33 | buf = [] |
| 34 | iterator = imap(soft_unicode, args) |
| 35 | for arg in iterator: |
| 36 | buf.append(arg) |
| 37 | if hasattr(arg, '__html__'): |
| 38 | return Markup(u'').join(chain(buf, iterator)) |
| 39 | return concat(buf) |
| 40 | |
| 41 | |
| 42 | def unicode_join(*args): |
| 43 | """Simple args to unicode conversion and concatenation.""" |
| 44 | return concat(imap(unicode, args)) |
| 45 | |
| 46 | |
Armin Ronacher | 203bfcb | 2008-04-24 21:54:44 +0200 | [diff] [blame] | 47 | class TemplateContext(object): |
Armin Ronacher | 8edbe49 | 2008-04-10 20:43:43 +0200 | [diff] [blame] | 48 | """Holds the variables of the local template or of the global one. It's |
Armin Ronacher | 9706fab | 2008-04-08 18:49:56 +0200 | [diff] [blame] | 49 | not save to use this class outside of the compiled code. For example |
| 50 | update and other methods will not work as they seem (they don't update |
| 51 | the exported variables for example). |
Armin Ronacher | c9705c2 | 2008-04-27 21:28:03 +0200 | [diff] [blame] | 52 | |
| 53 | The context is immutable. Modifications on `parent` must not happen and |
| 54 | modifications on `vars` are allowed from generated template code. However |
| 55 | functions that are passed the template context may not modify the context |
| 56 | in any way. |
Armin Ronacher | 9706fab | 2008-04-08 18:49:56 +0200 | [diff] [blame] | 57 | """ |
Armin Ronacher | e791c2a | 2008-04-07 18:39:54 +0200 | [diff] [blame] | 58 | |
Armin Ronacher | 203bfcb | 2008-04-24 21:54:44 +0200 | [diff] [blame] | 59 | def __init__(self, environment, parent, name, blocks): |
| 60 | self.parent = parent |
Armin Ronacher | 2feed1d | 2008-04-26 16:26:52 +0200 | [diff] [blame] | 61 | self.vars = vars = {} |
Armin Ronacher | c63243e | 2008-04-14 22:53:58 +0200 | [diff] [blame] | 62 | self.environment = environment |
Armin Ronacher | 203bfcb | 2008-04-24 21:54:44 +0200 | [diff] [blame] | 63 | self.exported_vars = set() |
Armin Ronacher | 68f7767 | 2008-04-17 11:50:39 +0200 | [diff] [blame] | 64 | self.name = name |
Armin Ronacher | 203bfcb | 2008-04-24 21:54:44 +0200 | [diff] [blame] | 65 | |
| 66 | # bind functions to the context of environment if required |
Armin Ronacher | 2feed1d | 2008-04-26 16:26:52 +0200 | [diff] [blame] | 67 | for name, obj in parent.iteritems(): |
Armin Ronacher | 203bfcb | 2008-04-24 21:54:44 +0200 | [diff] [blame] | 68 | if type(obj) is FunctionType: |
| 69 | if getattr(obj, 'contextfunction', 0): |
Armin Ronacher | 2feed1d | 2008-04-26 16:26:52 +0200 | [diff] [blame] | 70 | vars[name] = partial(obj, self) |
Armin Ronacher | 203bfcb | 2008-04-24 21:54:44 +0200 | [diff] [blame] | 71 | elif getattr(obj, 'environmentfunction', 0): |
Armin Ronacher | 2feed1d | 2008-04-26 16:26:52 +0200 | [diff] [blame] | 72 | vars[name] = partial(obj, environment) |
Armin Ronacher | 203bfcb | 2008-04-24 21:54:44 +0200 | [diff] [blame] | 73 | |
| 74 | # create the initial mapping of blocks. Whenever template inheritance |
| 75 | # takes place the runtime will update this mapping with the new blocks |
| 76 | # from the template. |
Armin Ronacher | 75cfb86 | 2008-04-11 13:47:22 +0200 | [diff] [blame] | 77 | self.blocks = dict((k, [v]) for k, v in blocks.iteritems()) |
Armin Ronacher | f059ec1 | 2008-04-11 22:21:00 +0200 | [diff] [blame] | 78 | |
Armin Ronacher | 203bfcb | 2008-04-24 21:54:44 +0200 | [diff] [blame] | 79 | def super(self, name, current): |
Armin Ronacher | 62f8a29 | 2008-04-13 23:18:05 +0200 | [diff] [blame] | 80 | """Render a parent block.""" |
Armin Ronacher | c9705c2 | 2008-04-27 21:28:03 +0200 | [diff] [blame] | 81 | try: |
| 82 | blocks = self.blocks[name] |
| 83 | pos = blocks.index(current) - 1 |
| 84 | if pos < 0: |
| 85 | raise IndexError() |
| 86 | except LookupError: |
Armin Ronacher | 9a82205 | 2008-04-17 18:44:07 +0200 | [diff] [blame] | 87 | return self.environment.undefined('there is no parent block ' |
Armin Ronacher | c9705c2 | 2008-04-27 21:28:03 +0200 | [diff] [blame] | 88 | 'called %r.' % name) |
Armin Ronacher | d134231 | 2008-04-28 12:20:12 +0200 | [diff] [blame] | 89 | wrap = self.environment.autoescape and Markup or (lambda x: x) |
| 90 | render = lambda: wrap(concat(blocks[pos](self))) |
Armin Ronacher | c9705c2 | 2008-04-27 21:28:03 +0200 | [diff] [blame] | 91 | render.__name__ = render.name = name |
| 92 | return render |
Armin Ronacher | e791c2a | 2008-04-07 18:39:54 +0200 | [diff] [blame] | 93 | |
Armin Ronacher | 5304229 | 2008-04-26 18:30:19 +0200 | [diff] [blame] | 94 | def get(self, key, default=None): |
Armin Ronacher | b5124e6 | 2008-04-25 00:36:14 +0200 | [diff] [blame] | 95 | """For dict compatibility""" |
Armin Ronacher | 5304229 | 2008-04-26 18:30:19 +0200 | [diff] [blame] | 96 | if key in self.vars: |
| 97 | return self.vars[key] |
| 98 | if key in self.parent: |
| 99 | return self.parent[key] |
| 100 | return default |
Armin Ronacher | b5124e6 | 2008-04-25 00:36:14 +0200 | [diff] [blame] | 101 | |
Armin Ronacher | 9706fab | 2008-04-08 18:49:56 +0200 | [diff] [blame] | 102 | def get_exported(self): |
Armin Ronacher | 203bfcb | 2008-04-24 21:54:44 +0200 | [diff] [blame] | 103 | """Get a new dict with the exported variables.""" |
Armin Ronacher | c9705c2 | 2008-04-27 21:28:03 +0200 | [diff] [blame] | 104 | return dict((k, self.vars[k]) for k in self.exported_vars) |
Armin Ronacher | 9706fab | 2008-04-08 18:49:56 +0200 | [diff] [blame] | 105 | |
Armin Ronacher | 203bfcb | 2008-04-24 21:54:44 +0200 | [diff] [blame] | 106 | def get_root(self): |
| 107 | """Return a new dict with all the non local variables.""" |
| 108 | return dict(self.parent) |
| 109 | |
| 110 | def get_all(self): |
| 111 | """Return a copy of the complete context as dict.""" |
| 112 | return dict(self.parent, **self.vars) |
| 113 | |
Armin Ronacher | c9705c2 | 2008-04-27 21:28:03 +0200 | [diff] [blame] | 114 | def clone(self): |
| 115 | """Return a copy of the context without the locals.""" |
| 116 | return self.__class__(self.environment, self.parent, |
| 117 | self.name, self.blocks) |
| 118 | |
Armin Ronacher | b5124e6 | 2008-04-25 00:36:14 +0200 | [diff] [blame] | 119 | def __contains__(self, name): |
| 120 | return name in self.vars or name in self.parent |
| 121 | |
Armin Ronacher | 203bfcb | 2008-04-24 21:54:44 +0200 | [diff] [blame] | 122 | def __getitem__(self, key): |
| 123 | if key in self.vars: |
| 124 | return self.vars[key] |
Armin Ronacher | 5304229 | 2008-04-26 18:30:19 +0200 | [diff] [blame] | 125 | if key in self.parent: |
Armin Ronacher | 203bfcb | 2008-04-24 21:54:44 +0200 | [diff] [blame] | 126 | return self.parent[key] |
Armin Ronacher | 5304229 | 2008-04-26 18:30:19 +0200 | [diff] [blame] | 127 | return self.environment.undefined(name=key) |
Armin Ronacher | 4f62a9f | 2008-04-08 18:09:13 +0200 | [diff] [blame] | 128 | |
Armin Ronacher | f059ec1 | 2008-04-11 22:21:00 +0200 | [diff] [blame] | 129 | def __repr__(self): |
| 130 | return '<%s %s of %r>' % ( |
| 131 | self.__class__.__name__, |
Armin Ronacher | 963f97d | 2008-04-25 11:44:59 +0200 | [diff] [blame] | 132 | repr(self.get_all()), |
Armin Ronacher | 68f7767 | 2008-04-17 11:50:39 +0200 | [diff] [blame] | 133 | self.name |
Armin Ronacher | f059ec1 | 2008-04-11 22:21:00 +0200 | [diff] [blame] | 134 | ) |
| 135 | |
| 136 | |
Armin Ronacher | c9705c2 | 2008-04-27 21:28:03 +0200 | [diff] [blame] | 137 | class TemplateReference(object): |
| 138 | """The `self` in templates.""" |
Armin Ronacher | 62f8a29 | 2008-04-13 23:18:05 +0200 | [diff] [blame] | 139 | |
Armin Ronacher | c9705c2 | 2008-04-27 21:28:03 +0200 | [diff] [blame] | 140 | def __init__(self, context): |
| 141 | self.__context = context |
Armin Ronacher | 62f8a29 | 2008-04-13 23:18:05 +0200 | [diff] [blame] | 142 | |
Armin Ronacher | c9705c2 | 2008-04-27 21:28:03 +0200 | [diff] [blame] | 143 | def __getitem__(self, name): |
| 144 | func = self.__context.blocks[name][-1] |
Armin Ronacher | d134231 | 2008-04-28 12:20:12 +0200 | [diff] [blame] | 145 | wrap = self.__context.environment.autoescape and \ |
| 146 | Markup or (lambda x: x) |
| 147 | render = lambda: wrap(concat(func(self.__context))) |
Armin Ronacher | c9705c2 | 2008-04-27 21:28:03 +0200 | [diff] [blame] | 148 | render.__name__ = render.name = name |
| 149 | return render |
Armin Ronacher | 62f8a29 | 2008-04-13 23:18:05 +0200 | [diff] [blame] | 150 | |
| 151 | def __repr__(self): |
| 152 | return '<%s %r>' % ( |
| 153 | self.__class__.__name__, |
Armin Ronacher | c9705c2 | 2008-04-27 21:28:03 +0200 | [diff] [blame] | 154 | self._context.name |
Armin Ronacher | 62f8a29 | 2008-04-13 23:18:05 +0200 | [diff] [blame] | 155 | ) |
| 156 | |
| 157 | |
Armin Ronacher | 32a910f | 2008-04-26 23:21:03 +0200 | [diff] [blame] | 158 | class LoopContext(object): |
| 159 | """A loop context for dynamic iteration.""" |
Armin Ronacher | 180a1bd | 2008-04-09 12:14:24 +0200 | [diff] [blame] | 160 | |
Armin Ronacher | 32a910f | 2008-04-26 23:21:03 +0200 | [diff] [blame] | 161 | def __init__(self, iterable, enforce_length=False): |
Armin Ronacher | 180a1bd | 2008-04-09 12:14:24 +0200 | [diff] [blame] | 162 | self._iterable = iterable |
Armin Ronacher | 32a910f | 2008-04-26 23:21:03 +0200 | [diff] [blame] | 163 | self._next = iter(iterable).next |
Armin Ronacher | d1d2f3d | 2008-04-09 14:02:55 +0200 | [diff] [blame] | 164 | self._length = None |
Armin Ronacher | 32a910f | 2008-04-26 23:21:03 +0200 | [diff] [blame] | 165 | self.index0 = -1 |
| 166 | if enforce_length: |
| 167 | len(self) |
Armin Ronacher | 180a1bd | 2008-04-09 12:14:24 +0200 | [diff] [blame] | 168 | |
Armin Ronacher | 2e9396b | 2008-04-16 14:21:57 +0200 | [diff] [blame] | 169 | def cycle(self, *args): |
| 170 | """A replacement for the old ``{% cycle %}`` tag.""" |
| 171 | if not args: |
| 172 | raise TypeError('no items for cycling given') |
| 173 | return args[self.index0 % len(args)] |
| 174 | |
Armin Ronacher | 180a1bd | 2008-04-09 12:14:24 +0200 | [diff] [blame] | 175 | first = property(lambda x: x.index0 == 0) |
| 176 | last = property(lambda x: x.revindex0 == 0) |
| 177 | index = property(lambda x: x.index0 + 1) |
Armin Ronacher | 10f3ba2 | 2008-04-18 11:30:37 +0200 | [diff] [blame] | 178 | revindex = property(lambda x: x.length - x.index0) |
| 179 | revindex0 = property(lambda x: x.length - x.index) |
Armin Ronacher | 2e9396b | 2008-04-16 14:21:57 +0200 | [diff] [blame] | 180 | |
| 181 | def __len__(self): |
| 182 | return self.length |
Armin Ronacher | 180a1bd | 2008-04-09 12:14:24 +0200 | [diff] [blame] | 183 | |
Armin Ronacher | d1d2f3d | 2008-04-09 14:02:55 +0200 | [diff] [blame] | 184 | def __iter__(self): |
Armin Ronacher | 3d8b784 | 2008-04-13 13:16:50 +0200 | [diff] [blame] | 185 | return self |
| 186 | |
| 187 | def next(self): |
| 188 | self.index0 += 1 |
| 189 | return self._next(), self |
Armin Ronacher | d1d2f3d | 2008-04-09 14:02:55 +0200 | [diff] [blame] | 190 | |
Armin Ronacher | 2e9396b | 2008-04-16 14:21:57 +0200 | [diff] [blame] | 191 | @property |
| 192 | def length(self): |
Armin Ronacher | d1d2f3d | 2008-04-09 14:02:55 +0200 | [diff] [blame] | 193 | if self._length is None: |
Armin Ronacher | 180a1bd | 2008-04-09 12:14:24 +0200 | [diff] [blame] | 194 | try: |
| 195 | length = len(self._iterable) |
| 196 | except TypeError: |
Armin Ronacher | d1d2f3d | 2008-04-09 14:02:55 +0200 | [diff] [blame] | 197 | self._iterable = tuple(self._iterable) |
Armin Ronacher | 3d8b784 | 2008-04-13 13:16:50 +0200 | [diff] [blame] | 198 | self._next = iter(self._iterable).next |
| 199 | length = len(tuple(self._iterable)) + self.index0 + 1 |
Armin Ronacher | 180a1bd | 2008-04-09 12:14:24 +0200 | [diff] [blame] | 200 | self._length = length |
| 201 | return self._length |
| 202 | |
Armin Ronacher | 2e9396b | 2008-04-16 14:21:57 +0200 | [diff] [blame] | 203 | def __repr__(self): |
Armin Ronacher | c9705c2 | 2008-04-27 21:28:03 +0200 | [diff] [blame] | 204 | return '<%s %r/%r>' % ( |
| 205 | self.__class__.__name__, |
| 206 | self.index, |
| 207 | self.length |
| 208 | ) |
Armin Ronacher | 2e9396b | 2008-04-16 14:21:57 +0200 | [diff] [blame] | 209 | |
Armin Ronacher | 180a1bd | 2008-04-09 12:14:24 +0200 | [diff] [blame] | 210 | |
Armin Ronacher | 4f62a9f | 2008-04-08 18:09:13 +0200 | [diff] [blame] | 211 | class Macro(object): |
Armin Ronacher | d55ab53 | 2008-04-09 16:13:39 +0200 | [diff] [blame] | 212 | """Wraps a macro.""" |
Armin Ronacher | 4f62a9f | 2008-04-08 18:09:13 +0200 | [diff] [blame] | 213 | |
Armin Ronacher | 963f97d | 2008-04-25 11:44:59 +0200 | [diff] [blame] | 214 | def __init__(self, environment, func, name, arguments, defaults, |
| 215 | catch_kwargs, catch_varargs, caller): |
Armin Ronacher | c63243e | 2008-04-14 22:53:58 +0200 | [diff] [blame] | 216 | self._environment = environment |
Armin Ronacher | 7108207 | 2008-04-12 14:19:36 +0200 | [diff] [blame] | 217 | self._func = func |
Armin Ronacher | 4f62a9f | 2008-04-08 18:09:13 +0200 | [diff] [blame] | 218 | self.name = name |
| 219 | self.arguments = arguments |
Armin Ronacher | 2feed1d | 2008-04-26 16:26:52 +0200 | [diff] [blame] | 220 | self.argument_count = len(arguments) |
Armin Ronacher | 4f62a9f | 2008-04-08 18:09:13 +0200 | [diff] [blame] | 221 | self.defaults = defaults |
Armin Ronacher | 963f97d | 2008-04-25 11:44:59 +0200 | [diff] [blame] | 222 | self.catch_kwargs = catch_kwargs |
| 223 | self.catch_varargs = catch_varargs |
Armin Ronacher | 7108207 | 2008-04-12 14:19:36 +0200 | [diff] [blame] | 224 | self.caller = caller |
Armin Ronacher | 4f62a9f | 2008-04-08 18:09:13 +0200 | [diff] [blame] | 225 | |
| 226 | def __call__(self, *args, **kwargs): |
Armin Ronacher | 2feed1d | 2008-04-26 16:26:52 +0200 | [diff] [blame] | 227 | self.argument_count = len(self.arguments) |
| 228 | if not self.catch_varargs and len(args) > self.argument_count: |
Armin Ronacher | 963f97d | 2008-04-25 11:44:59 +0200 | [diff] [blame] | 229 | raise TypeError('macro %r takes not more than %d argument(s)' % |
Armin Ronacher | 4f62a9f | 2008-04-08 18:09:13 +0200 | [diff] [blame] | 230 | (self.name, len(self.arguments))) |
Armin Ronacher | 2feed1d | 2008-04-26 16:26:52 +0200 | [diff] [blame] | 231 | arguments = [] |
Armin Ronacher | 9706fab | 2008-04-08 18:49:56 +0200 | [diff] [blame] | 232 | for idx, name in enumerate(self.arguments): |
| 233 | try: |
| 234 | value = args[idx] |
| 235 | except IndexError: |
| 236 | try: |
| 237 | value = kwargs.pop(name) |
| 238 | except KeyError: |
| 239 | try: |
Armin Ronacher | 2feed1d | 2008-04-26 16:26:52 +0200 | [diff] [blame] | 240 | value = self.defaults[idx - self.argument_count] |
Armin Ronacher | 9706fab | 2008-04-08 18:49:56 +0200 | [diff] [blame] | 241 | except IndexError: |
Armin Ronacher | 9a82205 | 2008-04-17 18:44:07 +0200 | [diff] [blame] | 242 | value = self._environment.undefined( |
| 243 | 'parameter %r was not provided' % name) |
Armin Ronacher | 2feed1d | 2008-04-26 16:26:52 +0200 | [diff] [blame] | 244 | arguments.append(value) |
| 245 | |
| 246 | # it's important that the order of these arguments does not change |
| 247 | # if not also changed in the compiler's `function_scoping` method. |
| 248 | # the order is caller, keyword arguments, positional arguments! |
Armin Ronacher | 7108207 | 2008-04-12 14:19:36 +0200 | [diff] [blame] | 249 | if self.caller: |
| 250 | caller = kwargs.pop('caller', None) |
| 251 | if caller is None: |
Armin Ronacher | 9a82205 | 2008-04-17 18:44:07 +0200 | [diff] [blame] | 252 | caller = self._environment.undefined('No caller defined') |
Armin Ronacher | 2feed1d | 2008-04-26 16:26:52 +0200 | [diff] [blame] | 253 | arguments.append(caller) |
Armin Ronacher | 963f97d | 2008-04-25 11:44:59 +0200 | [diff] [blame] | 254 | if self.catch_kwargs: |
Armin Ronacher | 2feed1d | 2008-04-26 16:26:52 +0200 | [diff] [blame] | 255 | arguments.append(kwargs) |
Armin Ronacher | 963f97d | 2008-04-25 11:44:59 +0200 | [diff] [blame] | 256 | elif kwargs: |
| 257 | raise TypeError('macro %r takes no keyword argument %r' % |
| 258 | (self.name, iter(kwargs).next())) |
| 259 | if self.catch_varargs: |
Armin Ronacher | 2feed1d | 2008-04-26 16:26:52 +0200 | [diff] [blame] | 260 | arguments.append(args[self.argument_count:]) |
| 261 | return self._func(*arguments) |
Armin Ronacher | 7108207 | 2008-04-12 14:19:36 +0200 | [diff] [blame] | 262 | |
| 263 | def __repr__(self): |
| 264 | return '<%s %s>' % ( |
| 265 | self.__class__.__name__, |
| 266 | self.name is None and 'anonymous' or repr(self.name) |
| 267 | ) |
Armin Ronacher | d1d2f3d | 2008-04-09 14:02:55 +0200 | [diff] [blame] | 268 | |
| 269 | |
Armin Ronacher | 203bfcb | 2008-04-24 21:54:44 +0200 | [diff] [blame] | 270 | def fail_with_undefined_error(self, *args, **kwargs): |
| 271 | """Regular callback function for undefined objects that raises an |
| 272 | `UndefinedError` on call. |
| 273 | """ |
| 274 | if self._undefined_hint is None: |
| 275 | if self._undefined_obj is None: |
| 276 | hint = '%r is undefined' % self._undefined_name |
| 277 | elif not isinstance(self._undefined_name, basestring): |
| 278 | hint = '%r object has no element %r' % ( |
| 279 | self._undefined_obj.__class__.__name__, |
| 280 | self._undefined_name |
| 281 | ) |
| 282 | else: |
| 283 | hint = '%r object has no attribute %r' % ( |
| 284 | self._undefined_obj.__class__.__name__, |
| 285 | self._undefined_name |
| 286 | ) |
| 287 | else: |
| 288 | hint = self._undefined_hint |
| 289 | raise UndefinedError(hint) |
| 290 | |
| 291 | |
Armin Ronacher | d1d2f3d | 2008-04-09 14:02:55 +0200 | [diff] [blame] | 292 | class Undefined(object): |
Armin Ronacher | d134231 | 2008-04-28 12:20:12 +0200 | [diff] [blame] | 293 | """The default undefined type. This undefined type can be printed and |
| 294 | iterated over, but every other access will raise an :exc:`UndefinedError`: |
| 295 | |
| 296 | >>> foo = Undefined(name='foo') |
| 297 | >>> str(foo) |
| 298 | '' |
| 299 | >>> not foo |
| 300 | True |
| 301 | >>> foo + 42 |
| 302 | Traceback (most recent call last): |
| 303 | ... |
| 304 | jinja2.exceptions.UndefinedError: 'foo' is undefined |
Armin Ronacher | c63243e | 2008-04-14 22:53:58 +0200 | [diff] [blame] | 305 | """ |
Armin Ronacher | 5304229 | 2008-04-26 18:30:19 +0200 | [diff] [blame] | 306 | __slots__ = ('_undefined_hint', '_undefined_obj', '_undefined_name') |
Armin Ronacher | d1d2f3d | 2008-04-09 14:02:55 +0200 | [diff] [blame] | 307 | |
Armin Ronacher | 9a82205 | 2008-04-17 18:44:07 +0200 | [diff] [blame] | 308 | def __init__(self, hint=None, obj=None, name=None): |
| 309 | self._undefined_hint = hint |
| 310 | self._undefined_obj = obj |
| 311 | self._undefined_name = name |
Armin Ronacher | d1d2f3d | 2008-04-09 14:02:55 +0200 | [diff] [blame] | 312 | |
Armin Ronacher | c63243e | 2008-04-14 22:53:58 +0200 | [diff] [blame] | 313 | __add__ = __radd__ = __mul__ = __rmul__ = __div__ = __rdiv__ = \ |
| 314 | __realdiv__ = __rrealdiv__ = __floordiv__ = __rfloordiv__ = \ |
| 315 | __mod__ = __rmod__ = __pos__ = __neg__ = __call__ = \ |
Armin Ronacher | 5304229 | 2008-04-26 18:30:19 +0200 | [diff] [blame] | 316 | __getattr__ = __getitem__ = __lt__ = __le__ = __gt__ = __ge__ = \ |
| 317 | fail_with_undefined_error |
Armin Ronacher | c63243e | 2008-04-14 22:53:58 +0200 | [diff] [blame] | 318 | |
| 319 | def __str__(self): |
| 320 | return self.__unicode__().encode('utf-8') |
Armin Ronacher | d1d2f3d | 2008-04-09 14:02:55 +0200 | [diff] [blame] | 321 | |
| 322 | def __repr__(self): |
Priit Laes | 4149a0e | 2008-04-17 19:04:44 +0200 | [diff] [blame] | 323 | return 'Undefined' |
Armin Ronacher | d1d2f3d | 2008-04-09 14:02:55 +0200 | [diff] [blame] | 324 | |
Armin Ronacher | 203bfcb | 2008-04-24 21:54:44 +0200 | [diff] [blame] | 325 | def __unicode__(self): |
| 326 | return u'' |
| 327 | |
Armin Ronacher | d1d2f3d | 2008-04-09 14:02:55 +0200 | [diff] [blame] | 328 | def __len__(self): |
| 329 | return 0 |
| 330 | |
| 331 | def __iter__(self): |
| 332 | if 0: |
| 333 | yield None |
Armin Ronacher | c63243e | 2008-04-14 22:53:58 +0200 | [diff] [blame] | 334 | |
| 335 | def __nonzero__(self): |
| 336 | return False |
| 337 | |
| 338 | |
| 339 | class DebugUndefined(Undefined): |
Armin Ronacher | d134231 | 2008-04-28 12:20:12 +0200 | [diff] [blame] | 340 | """An undefined that returns the debug info when printed. |
| 341 | |
| 342 | >>> foo = DebugUndefined(name='foo') |
| 343 | >>> str(foo) |
| 344 | '{{ foo }}' |
| 345 | >>> not foo |
| 346 | True |
| 347 | >>> foo + 42 |
| 348 | Traceback (most recent call last): |
| 349 | ... |
| 350 | jinja2.exceptions.UndefinedError: 'foo' is undefined |
| 351 | """ |
Armin Ronacher | 5304229 | 2008-04-26 18:30:19 +0200 | [diff] [blame] | 352 | __slots__ = () |
Armin Ronacher | c63243e | 2008-04-14 22:53:58 +0200 | [diff] [blame] | 353 | |
| 354 | def __unicode__(self): |
Armin Ronacher | 9a82205 | 2008-04-17 18:44:07 +0200 | [diff] [blame] | 355 | if self._undefined_hint is None: |
| 356 | if self._undefined_obj is None: |
| 357 | return u'{{ %s }}' % self._undefined_name |
| 358 | return '{{ no such element: %s[%r] }}' % ( |
| 359 | self._undefined_obj.__class__.__name__, |
| 360 | self._undefined_name |
| 361 | ) |
| 362 | return u'{{ undefined value printed: %s }}' % self._undefined_hint |
Armin Ronacher | c63243e | 2008-04-14 22:53:58 +0200 | [diff] [blame] | 363 | |
| 364 | |
| 365 | class StrictUndefined(Undefined): |
Armin Ronacher | 203bfcb | 2008-04-24 21:54:44 +0200 | [diff] [blame] | 366 | """An undefined that barks on print and iteration as well as boolean |
Armin Ronacher | 5304229 | 2008-04-26 18:30:19 +0200 | [diff] [blame] | 367 | tests and all kinds of comparisons. In other words: you can do nothing |
| 368 | with it except checking if it's defined using the `defined` test. |
Armin Ronacher | d134231 | 2008-04-28 12:20:12 +0200 | [diff] [blame] | 369 | |
| 370 | >>> foo = StrictUndefined(name='foo') |
| 371 | >>> str(foo) |
| 372 | Traceback (most recent call last): |
| 373 | ... |
| 374 | jinja2.exceptions.UndefinedError: 'foo' is undefined |
| 375 | >>> not foo |
| 376 | Traceback (most recent call last): |
| 377 | ... |
| 378 | jinja2.exceptions.UndefinedError: 'foo' is undefined |
| 379 | >>> foo + 42 |
| 380 | Traceback (most recent call last): |
| 381 | ... |
| 382 | jinja2.exceptions.UndefinedError: 'foo' is undefined |
Priit Laes | 4149a0e | 2008-04-17 19:04:44 +0200 | [diff] [blame] | 383 | """ |
Armin Ronacher | 5304229 | 2008-04-26 18:30:19 +0200 | [diff] [blame] | 384 | __slots__ = () |
| 385 | __iter__ = __unicode__ = __len__ = __nonzero__ = __eq__ = __ne__ = \ |
| 386 | fail_with_undefined_error |
Armin Ronacher | c63243e | 2008-04-14 22:53:58 +0200 | [diff] [blame] | 387 | |
Armin Ronacher | 5304229 | 2008-04-26 18:30:19 +0200 | [diff] [blame] | 388 | |
| 389 | # remove remaining slots attributes, after the metaclass did the magic they |
| 390 | # are unneeded and irritating as they contain wrong data for the subclasses. |
| 391 | del Undefined.__slots__, DebugUndefined.__slots__, StrictUndefined.__slots__ |