(?:\s\b[a-z_]+=\w+\s?)+)?\Z # kwargs match everything at the end in groups " name=arg"
15 | """, re.VERBOSE)
16 |
17 |
18 | class InlineUnrenderableError(Exception):
19 | """
20 | Any errors that are children of this error will be silenced by inlines.process
21 | unless settings.INLINE_DEBUG is true.
22 | """
23 | pass
24 |
25 | class InlineInputError(InlineUnrenderableError):
26 | pass
27 |
28 | class InlineValueError(InlineUnrenderableError):
29 | pass
30 |
31 | class InlineAttributeError(InlineUnrenderableError):
32 | pass
33 |
34 | class InlineNotRegisteredError(InlineUnrenderableError):
35 | pass
36 |
37 | class InlineUnparsableError(InlineUnrenderableError):
38 | pass
39 |
40 |
41 | def parse_inline(text):
42 | """
43 | Takes a string of text from a text inline and returns a 3 tuple of
44 | (name, value, **kwargs).
45 | """
46 |
47 | m = INLINE_SPLITTER.match(text)
48 | if not m:
49 | raise InlineUnparsableError
50 | args = m.group('args')
51 | name = m.group('name')
52 | value = ""
53 | kwtxt = ""
54 | kwargs = {}
55 | if args:
56 | kwtxt = INLINE_KWARG_PARSER.search(args).group('kwargs')
57 | value = re.sub("%s\Z" % kwtxt, "", args)
58 | value = value.strip()
59 | if m.group('variant'):
60 | kwargs['variant'] = m.group('variant')
61 | if kwtxt:
62 | for kws in kwtxt.split():
63 | k, v = kws.split('=')
64 | kwargs[str(k)] = v
65 | return (name, value, kwargs)
66 |
67 |
68 | def inline_for_model(model, variants=[], inline_args={}):
69 | """
70 | A shortcut function to produce ModelInlines for django models
71 | """
72 |
73 | if not isinstance(model, ModelBase):
74 | raise ValueError("inline_for_model requires it's argument to be a Django Model")
75 | d = dict(model=model)
76 | if variants:
77 | d['variants'] = variants
78 | if inline_args:
79 | d['args'] = inline_args
80 | class_name = "%sInline" % model._meta.module_name.capitalize()
81 | return type(class_name, (ModelInline,), d)
82 |
83 |
84 | class InlineBase(object):
85 | """
86 | A base class for overriding to provide simple inlines.
87 | The `render` method is the only required override. It should return a string.
88 | or at least something that can be coerced into a string.
89 | """
90 |
91 | def __init__(self, value, variant=None, context=None, template_dir="", **kwargs):
92 | self.value = value
93 | self.variant = variant
94 | self.kwargs = kwargs
95 |
96 | def render(self):
97 | raise NotImplementedError('This method must be defined in a subclass')
98 |
99 |
100 | class TemplateInline(object):
101 | """
102 | A base class for overriding to provide templated inlines.
103 | The `get_context` method is the only required override. It should return
104 | dictionary-like object that will be fed to the template as the context.
105 |
106 | If you instantiate your inline class with a context instance, it'll use
107 | that to set up your base context.
108 |
109 | Any extra arguments assigned to your inline are passed directly though to
110 | the context.
111 | """
112 |
113 | def __init__(self, value, variant=None, context=None, template_dir=None, **kwargs):
114 | self.value = value
115 | self.variant = variant
116 | self.context = context
117 | self.kwargs = kwargs
118 |
119 | self.template_dirs = []
120 | if template_dir:
121 | self.template_dirs.append(template_dir.strip('/').replace("'", '').replace('"', ''))
122 | self.template_dirs.append('inlines')
123 |
124 | def get_context(self):
125 | """
126 | This method must be defined in a subclass
127 | """
128 | raise NotImplementedError('This method must be defined in a subclass')
129 |
130 | def get_template_name(self):
131 | templates = []
132 | name = self.__class__.name
133 | for dir in self.template_dirs:
134 | if self.variant:
135 | templates.append('%s/%s.%s.html' % (dir, name, self.variant))
136 | templates.append('%s/%s.html' % (dir, name))
137 | return templates
138 |
139 | def render(self):
140 | if self.context:
141 | context = self.context
142 | else:
143 | context = Context()
144 | context.update(self.kwargs)
145 | context['variant'] = self.variant
146 | output = render_to_string(self.get_template_name(), self.get_context(), context)
147 | context.pop()
148 | return output
149 |
150 |
151 | class ModelInline(TemplateInline):
152 | """
153 | A base class for creating inlines for Django models. The `model` class
154 | attribute is the only required override. It should be assigned a django
155 | model class.
156 | """
157 |
158 | model = None
159 | help_text = "Takes the id of the desired object"
160 |
161 | @classmethod
162 | def get_app_label(self):
163 | return "%s/%s" % (self.model._meta.app_label, self.model._meta.module_name)
164 |
165 | def get_context(self):
166 | model = self.__class__.model
167 | if not isinstance(model, ModelBase):
168 | raise InlineAttributeError('ModelInline requires model to be set to a django model class')
169 | try:
170 | value = int(self.value)
171 | object = model.objects.get(pk=value)
172 | except ValueError:
173 | raise InlineInputError("'%s' could not be converted to an int" % self.value)
174 | except model.DoesNotExist:
175 | raise InlineInputError("'%s' could not be found in %s.%s" % (self.value, model._meta.app_label, model._meta.module_name))
176 | return { 'object': object }
177 |
178 |
179 | class Registry(object):
180 |
181 | def __init__(self):
182 | self._registry = {}
183 | self.START_TAG = getattr(settings, 'INLINES_START_TAG', '{{')
184 | self.END_TAG = getattr(settings, 'INLINES_END_TAG', '}}')
185 |
186 | @property
187 | def inline_finder(self):
188 | return re.compile(r'%(start)s\s*(.+?)\s*%(end)s' % {'start':self.START_TAG, 'end':self.END_TAG})
189 |
190 | def register(self, name, cls):
191 | if not hasattr(cls, 'render'):
192 | raise TypeError("You may only register inlines with a `render` method")
193 | cls.name = name
194 | self._registry[name] = cls
195 |
196 | def unregister(self, name):
197 | if not name in self._registry:
198 | raise InlineNotRegisteredError("Inline '%s' not registered. Unable to remove." % name)
199 | del(self._registry[name])
200 |
201 | def process(self, text, context=None, template_dir=None, **kwargs):
202 | def render(matchobj):
203 | try:
204 | text = matchobj.group(1)
205 | name, value, inline_kwargs = parse_inline(text)
206 | try:
207 | cls = self._registry[name]
208 | except KeyError:
209 | raise InlineNotRegisteredError('"%s" was not found as a registered inline' % name)
210 | inline = cls(value, context=context, template_dir=template_dir, **inline_kwargs)
211 | return str(inline.render())
212 | # Silence any InlineUnrenderableErrors unless INLINE_DEBUG is True
213 | except InlineUnrenderableError:
214 | debug = getattr(settings, "INLINE_DEBUG", False)
215 | if debug:
216 | raise
217 | else:
218 | return ""
219 | text = self.inline_finder.sub(render, text)
220 | return text
221 |
222 |
223 | # The default registry.
224 | registry = Registry()
225 |
--------------------------------------------------------------------------------
/tests/core/tests/templatetags.py:
--------------------------------------------------------------------------------
1 | from django.test import TestCase
2 | from django.template import Template, Context
3 | from django_inlines import inlines
4 | from django_inlines.samples import YoutubeInline
5 | from django_inlines.templatetags.inlines import stripinlines
6 | from test_inlines import QuineInline, DoubleInline
7 |
8 |
9 | class StripInlinesTestCase(TestCase):
10 | def render(self, template_string, context_dict=None):
11 | """A shortcut for testing template output."""
12 | if context_dict is None:
13 | context_dict = {}
14 |
15 | c = Context(context_dict)
16 | t = Template(template_string)
17 | return t.render(c)
18 |
19 | def test_strip_inlines(self):
20 | IN = "This is my YouTube video: {{ youtube C_ZebDKv1zo }}"
21 | self.assertEqual(stripinlines(IN), "This is my YouTube video: ")
22 |
23 | def test_simple_usage(self):
24 | inlines.registry.register('youtube', YoutubeInline)
25 |
26 | template = u"{% load inlines %}{{ body|stripinlines }}
"
27 | context = {
28 | 'body': u"This is my YouTube video: {{ youtube C_ZebDKv1zo }}",
29 | }
30 | self.assertEqual(self.render(template, context), u'This is my YouTube video:
')
31 |
32 |
33 | class ProcessInlinesTestCase(TestCase):
34 | def render(self, template_string, context_dict=None):
35 | """A shortcut for testing template output."""
36 | if context_dict is None:
37 | context_dict = {}
38 |
39 | c = Context(context_dict)
40 | t = Template(template_string)
41 | return t.render(c)
42 |
43 | def setUp(self):
44 | super(ProcessInlinesTestCase, self).setUp()
45 |
46 | # Stow.
47 | self.old_registry = inlines.registry
48 | inlines.registry = inlines.Registry()
49 |
50 | def tearDown(self):
51 | inlines.registry = self.old_registry
52 | super(ProcessInlinesTestCase, self).tearDown()
53 |
54 | def test_simple_usage(self):
55 | inlines.registry.register('youtube', YoutubeInline)
56 |
57 | template = u"{% load inlines %}{% process_inlines body %}
"
58 | context = {
59 | 'body': u"This is my YouTube video: {{ youtube C_ZebDKv1zo }}",
60 | }
61 | self.assertEqual(self.render(template, context), u'This is my YouTube video:
\n')
62 |
63 | def test_usage_with_args_and_unicode(self):
64 | inlines.registry.register('youtube', YoutubeInline)
65 |
66 | template = u"{% load inlines %}{% process_inlines body %}
"
67 | context = {
68 | 'body': u"This is my YouTube video: {{ youtube C_ZebDKv1zo height=295 width=480 }}",
69 | }
70 | self.assertEqual(self.render(template, context), u'This is my YouTube video:
\n')
71 |
72 | def test_asvar(self):
73 | inlines.registry.register('youtube', YoutubeInline)
74 |
75 | template = u"{% load inlines %}{% process_inlines body as body %}{{ body|safe }}
"
76 | context = {
77 | 'body': u"This is my YouTube video: {{ youtube C_ZebDKv1zo }}",
78 | }
79 | self.assertEqual(self.render(template, context), u'This is my YouTube video:
\n')
80 |
81 | def test_asvar_and_template_dir(self):
82 | """
83 | The template tag shouldn't care what order the arguments are in.
84 | """
85 | inlines.registry.register('youtube', YoutubeInline)
86 |
87 | template = "{% load inlines %}{% process_inlines body as body in 'youtube_inlines' %}{{ body|safe }}
"
88 | context = {
89 | 'body': u"This is my YouTube video: {{ youtube C_ZebDKv1zo }}",
90 | }
91 | self.assertEqual(self.render(template, context), u'This is my YouTube video:
\nC_ZebDKv1zo\n
\n')
92 |
93 | template = "{% load inlines %}{% process_inlines body in 'youtube_inlines' as body %}{{ body|safe }}
"
94 | self.assertEqual(self.render(template, context), u'This is my YouTube video:
\nC_ZebDKv1zo\n
\n')
95 |
96 | def test_usage_with_multiple_inlines(self):
97 | inlines.registry.register('quine', QuineInline)
98 | inlines.registry.register('double', DoubleInline)
99 |
100 | template = "{% load inlines %}{% process_inlines body %}
"
101 | context = {
102 | 'body': u"Some text {{ quine Why hello }} but {{ double your fun }}.",
103 | }
104 | self.assertEqual(inlines.registry.process(context['body']), 'Some text {{ quine Why hello }} but your funyour fun.')
105 | self.assertEqual(self.render(template, context), u'Some text {{ quine Why hello }} but your funyour fun.
')
106 |
107 | def test_usage_with_template_dirs(self):
108 | inlines.registry.register('youtube', YoutubeInline)
109 |
110 | template = "{% load inlines %}{% process_inlines body in 'youtube_inlines' %}
"
111 | context = {
112 | 'body': u"This is my YouTube video: {{ youtube C_ZebDKv1zo }}",
113 | }
114 | self.assertEqual(self.render(template, context), u'This is my YouTube video:
\nC_ZebDKv1zo\n
\n')
115 |
116 | def test_that_context_gets_passed_through(self):
117 | inlines.registry.register('youtube', YoutubeInline)
118 |
119 | template = "{% load inlines %}{% with 'b' as bold %}{% process_inlines body in 'youtube_inlines' %}{% endwith %}
"
120 | context = {
121 | 'body': u"This is my YouTube video: {{ youtube C_ZebDKv1zo }}",
122 | }
123 | self.assertEqual(self.render(template, context), u'This is my YouTube video:
\nC_ZebDKv1zo\n
\n')
124 |
125 | def test_that_context_gets_popped(self):
126 | inlines.registry.register('youtube', YoutubeInline)
127 |
128 | template = """{% load inlines %}{% process_inlines body in 'youtube_inlines' %} {{ test }}
"""
129 | context = {
130 | 'body': u"This is my YouTube video: {{ youtube C_ZebDKv1zo bold=bold }} {{ youtube C_ZebDKv1zo }}",
131 | 'test': u"green"
132 | }
133 | self.assertEqual(self.render(template, context), u'This is my YouTube video:
\nC_ZebDKv1zo\n
\n \nC_ZebDKv1zo\n
\n green')
134 |
135 | def test_usage_with_template_dirs_fallback(self):
136 | """
137 | A if the a template in the specified dir doesn't exist it should fallback
138 | to using the default of inlines.
139 | """
140 |
141 | from django.conf import settings
142 | inlines.registry.register('youtube', YoutubeInline)
143 |
144 | template = "{% load inlines %}{% process_inlines body in 'nonexistent_inlines' %}
"
145 | context = {
146 | 'body': u"This is my YouTube video: {{ youtube C_ZebDKv1zo }}",
147 | }
148 | self.assertEqual(self.render(template, context), u'This is my YouTube video:
\n')
149 |
--------------------------------------------------------------------------------
6 | {% endif %}
7 | {% if inline.help_text %}{{ inline.help_text }}{% endif %}
8 |