def technical_404_response(request, exception): "Create a technical 404 error response. The exception should be the Http404." try: tried = exception.args[0]['tried'] except (IndexError, TypeError, KeyError): tried = [] else: if not tried: # tried exists but is an empty list. The URLconf must've been empty. return empty_urlconf(request) urlconf = getattr(request, 'urlconf', settings.ROOT_URLCONF) if isinstance(urlconf, types.ModuleType): urlconf = urlconf.__name__ t = Template(TECHNICAL_404_TEMPLATE, name='Technical 404 template') c = Context({ 'urlconf': urlconf, 'root_urlconf': settings.ROOT_URLCONF, 'request_path': request.path_info[1:], # Trim leading slash 'urlpatterns': tried, 'reason': smart_str(exception, errors='replace'), 'request': request, 'settings': get_safe_settings(), }) return HttpResponseNotFound(t.render(c), mimetype='text/html')
def test_parsing_errors(self): "There are various ways that the flatpages template tag won't parse" render = lambda t: Template(t).render(Context()) self.assertRaises(TemplateSyntaxError, render, "{% load flatpages %}{% get_flatpages %}") self.assertRaises(TemplateSyntaxError, render, "{% load flatpages %}{% get_flatpages as %}") self.assertRaises( TemplateSyntaxError, render, "{% load flatpages %}{% get_flatpages cheesecake flatpages %}") self.assertRaises( TemplateSyntaxError, render, "{% load flatpages %}{% get_flatpages as flatpages asdf%}") self.assertRaises( TemplateSyntaxError, render, "{% load flatpages %}{% get_flatpages cheesecake user as flatpages %}" ) self.assertRaises( TemplateSyntaxError, render, "{% load flatpages %}{% get_flatpages for user as flatpages asdf%}" ) self.assertRaises( TemplateSyntaxError, render, "{% load flatpages %}{% get_flatpages prefix for user as flatpages asdf%}" )
def test_get_flatpages_with_prefix(self): "The flatpage template tag retrives unregistered prefixed flatpages by default" out = Template("{% load flatpages %}" "{% get_flatpages '/location/' as location_flatpages %}" "{% for page in location_flatpages %}" "{{ page.title }}," "{% endfor %}").render(Context()) self.assertEqual(out, "A Nested Flatpage,")
def resolve_context(self, context): """Converts context data into a full Context object (assuming it isn't already a Context object). """ if isinstance(context, Context): return context else: return Context(context)
def test_textile(self): t = Template("{% load markup %}{{ textile_content|textile }}") rendered = t.render(Context({'textile_content': self.textile_content})).strip() self.assertEqual( rendered.replace('\t', ''), """<p>Paragraph 1</p> <p>Paragraph 2 with “quotes” and <code>code</code></p>""")
def test_get_flatpages_with_variable_prefix(self): "The prefix for the flatpage template tag can be a template variable" out = Template( "{% load flatpages %}" "{% get_flatpages location_prefix as location_flatpages %}" "{% for page in location_flatpages %}" "{{ page.title }}," "{% endfor %}").render(Context({'location_prefix': '/location/'})) self.assertEqual(out, "A Nested Flatpage,")
def test_get_flatpages_with_prefix_for_anon_user(self): "The flatpage template tag retrives unregistered prefixed flatpages for an anonymous user" out = Template( "{% load flatpages %}" "{% get_flatpages '/location/' for anonuser as location_flatpages %}" "{% for page in location_flatpages %}" "{{ page.title }}," "{% endfor %}").render(Context({'anonuser': AnonymousUser()})) self.assertEqual(out, "A Nested Flatpage,")
def test_get_flatpages_with_prefix_for_user(self): "The flatpage template tag retrive prefixed flatpages for an authenticated user" out = Template( "{% load flatpages %}" "{% get_flatpages '/location/' for me as location_flatpages %}" "{% for page in location_flatpages %}" "{{ page.title }}," "{% endfor %}").render(Context({'me': self.me})) self.assertEqual(out, "A Nested Flatpage,Sekrit Nested Flatpage,")
def test_get_flatpages_tag_for_user(self): "The flatpage template tag retrives all flatpages for an authenticated user" out = Template("{% load flatpages %}" "{% get_flatpages for me as flatpages %}" "{% for page in flatpages %}" "{{ page.title }}," "{% endfor %}").render(Context({'me': self.me})) self.assertEqual( out, "A Flatpage,A Nested Flatpage,Sekrit Nested Flatpage,Sekrit Flatpage," )
def done(self, form_list, **kwargs): c = Context({ 'form_list': [x.cleaned_data for x in form_list], 'all_cleaned_data': self.get_all_cleaned_data(), }) for form in self.form_list.keys(): c[form] = self.get_cleaned_data_for_step(form) c['this_will_fail'] = self.get_cleaned_data_for_step('this_will_fail') return HttpResponse(Template('').render(c))
def humanize_tester(self, test_list, result_list, method): # Using max below ensures we go through both lists # However, if the lists are not equal length, this raises an exception for test_content, result in zip(test_list, result_list): t = Template('{%% load humanize %%}{{ test_content|%s }}' % method) rendered = t.render(Context(locals())).strip() self.assertEqual( rendered, escape(result), msg="%s test failed, produced '%s', should've produced '%s'" % (method, rendered, result))
def csrf_failure(request, reason=""): """ Default view used when request fails CSRF protection """ from my_django.middleware.csrf import REASON_NO_REFERER t = Template(CSRF_FAILURE_TEMPLATE) c = Context({ 'DEBUG': settings.DEBUG, 'reason': reason, 'no_referer': reason == REASON_NO_REFERER }) return HttpResponseForbidden(t.render(c), mimetype='text/html')
def email(self, comment, content_object, request): """ Send email notification of a new comment to site staff when email notifications have been requested. """ if not self.email_notification: return recipient_list = [manager_tuple[1] for manager_tuple in settings.MANAGERS] t = loader.get_template('comments/comment_notification_email.txt') c = Context({ 'comment': comment, 'content_object': content_object }) subject = '[%s] New comment posted on "%s"' % (Site.objects.get_current().name, content_object) message = t.render(c) send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, recipient_list, fail_silently=True)
def test_docutils(self): t = Template("{% load markup %}{{ rest_content|restructuredtext }}") rendered = t.render(Context({'rest_content': self.rest_content})).strip() # Different versions of docutils return slightly different HTML try: # Docutils v0.4 and earlier self.assertEqual( rendered, """<p>Paragraph 1</p> <p>Paragraph 2 with a <a class="reference" href="http://www.example.com/">link</a></p>""" ) except AssertionError, e: # Docutils from SVN (which will become 0.5) self.assertEqual( rendered, """<p>Paragraph 1</p> <p>Paragraph 2 with a <a class="reference external" href="http://www.example.com/">link</a></p>""" )
def directory_index(path, fullpath): try: t = loader.select_template(['static/directory_index.html', 'static/directory_index']) except TemplateDoesNotExist: t = Template(DEFAULT_DIRECTORY_INDEX_TEMPLATE, name='Default directory index template') files = [] for f in os.listdir(fullpath): if not f.startswith('.'): if os.path.isdir(os.path.join(fullpath, f)): f += '/' files.append(f) c = Context({ 'directory' : path + '/', 'file_list' : files, }) return HttpResponse(t.render(c))
def test_no_markdown(self): t = Template("{% load markup %}{{ markdown_content|markdown }}") rendered = t.render( Context({'markdown_content': self.markdown_content})).strip() self.assertEqual(rendered, self.markdown_content)
def test_markdown_attribute_enable(self): t = Template("{% load markup %}{{ markdown_content|markdown }}") markdown_content = "{@onclick=alert('hi')}some paragraph" rendered = t.render(Context({'markdown_content': markdown_content})).strip() self.assertFalse('@' in rendered)
def test_markdown(self): t = Template("{% load markup %}{{ markdown_content|markdown }}") rendered = t.render( Context({'markdown_content': self.markdown_content})).strip() pattern = re.compile("""<p>Paragraph 1\s*</p>\s*<h2>\s*An h2</h2>""") self.assertTrue(pattern.match(rendered))
def test_no_textile(self): t = Template("{% load markup %}{{ textile_content|textile }}") rendered = t.render(Context({'textile_content': self.textile_content})).strip() self.assertEqual(rendered, escape(self.textile_content))
from my_django.forms.widgets import Textarea from my_django.template import loader, Context from my_django.templatetags.static import static from my_django.utils import translation from my_django.contrib.gis.gdal import OGRException from my_django.contrib.gis.geos import GEOSGeometry, GEOSException # Creating a template context that contains Django settings # values needed by admin map templates. geo_context = Context({'ADMIN_MEDIA_PREFIX' : static('admin/'), 'LANGUAGE_BIDI' : translation.get_language_bidi()}) class OpenLayersWidget(Textarea): """ Renders an OpenLayers map using the WKT of the geometry. """ def render(self, name, value, attrs=None): # Update the template parameters with any attributes passed in. if attrs: self.params.update(attrs) # Defaulting the WKT value to a blank string -- this # will be tested in the JavaScript and the appropriate # interface will be constructed. self.params['wkt'] = '' # If a string reaches here (via a validation error on another # field) then just reconstruct the Geometry. if isinstance(value, basestring): try: value = GEOSGeometry(value)
def test_no_docutils(self): t = Template("{% load markup %}{{ rest_content|restructuredtext }}") rendered = t.render(Context({'rest_content': self.rest_content})).strip() self.assertEqual(rendered, self.rest_content)
extra_files.extend(map(lambda x: x.strip(), file.split(','))) if self.verbosity >= 2: self.stdout.write("Rendering %s template files with " "extensions: %s\n" % (app_or_project, ', '.join(extensions))) self.stdout.write("Rendering %s template files with " "filenames: %s\n" % (app_or_project, ', '.join(extra_files))) base_name = '%s_name' % app_or_project base_subdir = '%s_template' % app_or_project base_directory = '%s_directory' % app_or_project context = Context( dict(options, **{ base_name: name, base_directory: top_dir, })) # Setup a stub settings environment for template rendering from my_django.conf import settings if not settings.configured: settings.configure() template_dir = self.handle_template(options.get('template'), base_subdir) prefix_length = len(template_dir) + 1 for root, dirs, files in os.walk(template_dir): path_rest = root[prefix_length:]
def get_traceback_html(self): "Return HTML version of debug 500 HTTP error page." t = Template(TECHNICAL_500_TEMPLATE, name='Technical 500 template') c = Context(self.get_traceback_data()) return t.render(c)
def get_traceback_text(self): "Return plain text version of debug 500 HTTP error page." t = Template(TECHNICAL_500_TEXT_TEMPLATE, name='Technical 500 template') c = Context(self.get_traceback_data(), autoescape=False) return t.render(c)
def empty_urlconf(request): "Create an empty URLconf 404 error response." t = Template(EMPTY_URLCONF_TEMPLATE, name='Empty URLConf template') c = Context({'project_name': settings.SETTINGS_MODULE.split('.')[0]}) return HttpResponse(t.render(c), mimetype='text/html')