X-Git-Url: https://vcs.fsf.org/?a=blobdiff_plain;f=mediagoblin%2Futil.py;h=ab219df034e9c0d0ee0c36e8330d3512fa94108f;hb=42ef819cbb7edb2aecbc39f60ecfbfaee59b5039;hp=867c4380b9a4852468106477d21286f4984eb71c;hpb=140e21028b565cf4c13d05962658ad010c81dccf;p=mediagoblin.git diff --git a/mediagoblin/util.py b/mediagoblin/util.py index 867c4380..ab219df0 100644 --- a/mediagoblin/util.py +++ b/mediagoblin/util.py @@ -20,17 +20,20 @@ import pkg_resources import smtplib import sys import re -import jinja2 -from mediagoblin.db.util import ObjectId -import translitcodec - -from mediagoblin import globals as mgoblin_globals - import urllib from math import ceil import copy -import decorators -from webob import exc + +from babel.localedata import exists +import jinja2 +import translitcodec +from webob import Response, exc +from lxml.html.clean import Cleaner +import markdown + +from mediagoblin import mg_globals +from mediagoblin import messages +from mediagoblin.db.util import ObjectId TESTS_ENABLED = False def _activate_testing(): @@ -41,20 +44,27 @@ def _activate_testing(): TESTS_ENABLED = True -def get_jinja_loader(user_template_path=None): +def clear_test_buckets(): """ - Set up the Jinja template loaders, possibly allowing for user - overridden templates. + We store some things for testing purposes that should be cleared + when we want a "clean slate" of information for our next round of + tests. Call this function to wipe all that stuff clean. - (In the future we may have another system for providing theming; - for now this is good enough.) + Also wipes out some other things we might redefine during testing, + like the jinja envs. """ - if user_template_path: - return jinja2.ChoiceLoader( - [jinja2.FileSystemLoader(user_template_path), - jinja2.PackageLoader('mediagoblin', 'templates')]) - else: - return jinja2.PackageLoader('mediagoblin', 'templates') + global SETUP_JINJA_ENVS + SETUP_JINJA_ENVS = {} + + global EMAIL_TEST_INBOX + global EMAIL_TEST_MBOX_INBOX + EMAIL_TEST_INBOX = [] + EMAIL_TEST_MBOX_INBOX = [] + + clear_test_template_context() + + +SETUP_JINJA_ENVS = {} def get_jinja_env(template_loader, locale): @@ -66,17 +76,66 @@ def get_jinja_env(template_loader, locale): """ setup_gettext(locale) + # If we have a jinja environment set up with this locale, just + # return that one. + if SETUP_JINJA_ENVS.has_key(locale): + return SETUP_JINJA_ENVS[locale] + template_env = jinja2.Environment( loader=template_loader, autoescape=True, - extensions=['jinja2.ext.i18n']) + extensions=['jinja2.ext.i18n', 'jinja2.ext.autoescape']) template_env.install_gettext_callables( - mgoblin_globals.translations.gettext, - mgoblin_globals.translations.ngettext) + mg_globals.translations.gettext, + mg_globals.translations.ngettext) + + # All templates will know how to ... + # ... fetch all waiting messages and remove them from the queue + template_env.globals['fetch_messages'] = messages.fetch_messages + + if exists(locale): + SETUP_JINJA_ENVS[locale] = template_env return template_env +# We'll store context information here when doing unit tests +TEMPLATE_TEST_CONTEXT = {} + + +def render_template(request, template_path, context): + """ + Render a template with context. + + Always inserts the request into the context, so you don't have to. + Also stores the context if we're doing unit tests. Helpful! + """ + template = request.template_env.get_template( + template_path) + context['request'] = request + rendered = template.render(context) + + if TESTS_ENABLED: + TEMPLATE_TEST_CONTEXT[template_path] = context + + return rendered + + +def clear_test_template_context(): + global TEMPLATE_TEST_CONTEXT + TEMPLATE_TEST_CONTEXT = {} + + +def render_to_response(request, template, context): + """Much like Django's shortcut.render()""" + return Response(render_template(request, template, context)) + + +def redirect(request, *args, **kwargs): + """Returns a HTTPFound(), takes a request and then urlgen params""" + return exc.HTTPFound(location=request.urlgen(*args, **kwargs)) + + def setup_user_in_request(request): """ Examine a request and tack on a request.user parameter if that's @@ -193,9 +252,9 @@ def send_email(from_addr, to_addrs, subject, message_body): - message_body: email body text """ # TODO: make a mock mhost if testing is enabled - if TESTS_ENABLED or mgoblin_globals.email_debug_mode: + if TESTS_ENABLED or mg_globals.email_debug_mode: mhost = FakeMhost() - elif not mgoblin_globals.email_debug_mode: + elif not mg_globals.email_debug_mode: mhost = smtplib.SMTP() mhost.connect() @@ -208,7 +267,7 @@ def send_email(from_addr, to_addrs, subject, message_body): if TESTS_ENABLED: EMAIL_TEST_INBOX.append(message) - if getattr(mgoblin_globals, 'email_debug_mode', False): + if getattr(mg_globals, 'email_debug_mode', False): print u"===== Email =====" print u"From address: %s" % message['From'] print u"To addresses: %s" % message['To'] @@ -280,6 +339,53 @@ def get_locale_from_request(request): return locale_to_lower_upper(target_lang) +# A super strict version of the lxml.html cleaner class +HTML_CLEANER = Cleaner( + scripts=True, + javascript=True, + comments=True, + style=True, + links=True, + page_structure=True, + processing_instructions=True, + embedded=True, + frames=True, + forms=True, + annoying_tags=True, + allow_tags=[ + 'div', 'b', 'i', 'em', 'strong', 'p', 'ul', 'ol', 'li', 'a', 'br'], + remove_unknown_tags=False, # can't be used with allow_tags + safe_attrs_only=True, + add_nofollow=True, # for now + host_whitelist=(), + whitelist_tags=set([])) + + +def clean_html(html): + # clean_html barfs on an empty string + if not html: + return u'' + + return HTML_CLEANER.clean_html(html) + + +MARKDOWN_INSTANCE = markdown.Markdown(safe_mode='escape') + + +def cleaned_markdown_conversion(text): + """ + Take a block of text, run it through MarkDown, and clean its HTML. + """ + # Markdown will do nothing with and clean_html can do nothing with + # an empty string :) + if not text: + return u'' + + return clean_html(MARKDOWN_INSTANCE.convert(text)) + + +SETUP_GETTEXTS = {} + def setup_gettext(locale): """ Setup the gettext instance based on this locale @@ -290,21 +396,29 @@ def setup_gettext(locale): # TODO: fallback nicely on translations from pt_PT to pt if not # available, etc. - this_gettext = gettext.translation( - 'mediagoblin', TRANSLATIONS_PATH, [locale], fallback=True) + if SETUP_GETTEXTS.has_key(locale): + this_gettext = SETUP_GETTEXTS[locale] + else: + this_gettext = gettext.translation( + 'mediagoblin', TRANSLATIONS_PATH, [locale], fallback=True) + if exists(locale): + SETUP_GETTEXTS[locale] = this_gettext - mgoblin_globals.setup_globals( + mg_globals.setup_globals( translations=this_gettext) +PAGINATION_DEFAULT_PER_PAGE = 30 + class Pagination(object): """ - Pagination class, - initialization through __init__(self, cursor, page=1, per_page=2): - get actual data slice through __call__() + Pagination class for mongodb queries. + + Initialization through __init__(self, cursor, page=1, per_page=2), + get actual data slice through __call__(). """ - def __init__(self, page, cursor, per_page=2): + def __init__(self, page, cursor, per_page=PAGINATION_DEFAULT_PER_PAGE): """ Initializes Pagination @@ -350,13 +464,20 @@ class Pagination(object): yield num last = num - def get_page_url(self, path_info, page_no, get_params=None): + def get_page_url_explicit(self, base_url, get_params, page_no): """ - Get a new page based of the path_info, the new page number, - and existing get parameters. + Get a page url by adding a page= parameter to the base url """ new_get_params = copy.copy(get_params or {}) new_get_params['page'] = page_no return "%s?%s" % ( - path_info, urllib.urlencode(new_get_params)) - + base_url, urllib.urlencode(new_get_params)) + + def get_page_url(self, request, page_no): + """ + Get a new page url based of the request, and the new page number. + + This is a nice wrapper around get_page_url_explicit() + """ + return self.get_page_url_explicit( + request.path_info, request.GET, page_no)