[bug 1016466] Remove funfactory

Funfactory... It's not you, it's me. We're just not good for each other
anymore. I look to the future, and it's a future of double rainbows and
misty sunrises. It's a future where I've got more control and in turn
more responsibility. It's a future where I'm empowered to have my own
successes, and my own mistakes. Maybe I'll double the Firefox userbase.
Maybe I'll become the cornerstone of a bad news cycle (again). I don't
know for certain what will happen, but I know it needs to happen without
you.

Be well, Funfactory. I hope we can still be friends.

fjord/analytics/views.py

@@ -15,7 +15,6 @@
 from django.views.decorators.http import require_POST
 
 from elasticutils.contrib.django import F, es_required_or_50x
-from funfactory.urlresolvers import reverse
 from mobility.decorators import mobile_template
 from tower import ugettext as _
 
@@ -24,6 +23,7 @@
     zero_fill
 )
 from fjord.base.helpers import locale_name
+from fjord.base.urlresolvers import reverse
 from fjord.base.util import (
     analyzer_required,
     check_new_user,

fjord/base/browserid.py

@@ -3,9 +3,9 @@
 from django.http import HttpResponseRedirect
 
 from django_browserid.views import Verify
-from funfactory.urlresolvers import reverse
 
 from fjord.base.models import Profile
+from fjord.base.urlresolvers import reverse
 
 
 class FjordVerify(Verify):

fjord/base/context_processors.py

@@ -0,0 +1,15 @@
+from django.conf import settings
+from django.utils import translation
+
+
+def i18n(request):
+    return {'LANGUAGES': settings.LANGUAGES,
+            'LANG': settings.LANGUAGE_URL_MAP.get(translation.get_language())
+                    or translation.get_language(),
+            'DIR': 'rtl' if translation.get_language_bidi() else 'ltr',
+            }
+
+
+def globals(request):
+    return {'request': request,
+            'settings': settings}

fjord/base/helpers.py

@@ -1,13 +1,83 @@
-import time
+import datetime
 import json
-from datetime import datetime, timedelta
+import time
+import urllib
+import urlparse
 
 from django.contrib.humanize.templatetags import humanize
+from django.contrib.staticfiles.storage import staticfiles_storage
+from django.template import defaultfilters
+from django.utils.encoding import smart_str
+from django.utils.html import strip_tags
 
+import jinja2
 from jingo import register
 from tower import ugettext_lazy as _lazy
 from product_details import product_details
 
+from fjord.base.urlresolvers import reverse
+
+
+# Yanking filters from Django.
+register.filter(strip_tags)
+register.filter(defaultfilters.timesince)
+register.filter(defaultfilters.truncatewords)
+
+
+@register.function
+def thisyear():
+    """The current year."""
+    return jinja2.Markup(datetime.date.today().year)
+
+
+@register.function
+def url(viewname, *args, **kwargs):
+    """Helper for Django's ``reverse`` in templates."""
+    return reverse(viewname, args=args, kwargs=kwargs)
+
+
+@register.filter
+def urlparams(url_, hash=None, **query):
+    """Add a fragment and/or query paramaters to a URL.
+
+    New query params will be appended to exising parameters, except duplicate
+    names, which will be replaced.
+    """
+    url = urlparse.urlparse(url_)
+    fragment = hash if hash is not None else url.fragment
+
+    # Use dict(parse_qsl) so we don't get lists of values.
+    q = url.query
+    query_dict = dict(urlparse.parse_qsl(smart_str(q))) if q else {}
+    query_dict.update((k, v) for k, v in query.items())
+
+    query_string = _urlencode([(k, v) for k, v in query_dict.items()
+                               if v is not None])
+    new = urlparse.ParseResult(url.scheme, url.netloc, url.path, url.params,
+                               query_string, fragment)
+    return new.geturl()
+
+
+def _urlencode(items):
+    """A Unicode-safe URLencoder."""
+    try:
+        return urllib.urlencode(items)
+    except UnicodeEncodeError:
+        return urllib.urlencode([(k, smart_str(v)) for k, v in items])
+
+
+@register.filter
+def urlencode(txt):
+    """Url encode a path."""
+    if isinstance(txt, unicode):
+        txt = txt.encode('utf-8')
+    return urllib.quote_plus(txt)
+
+
+@register.function
+def static(path):
+    return staticfiles_storage.url(path)
+
 
 @register.filter
 def naturaltime(*args):
@@ -44,8 +114,8 @@ def locale_name(locale, native=False, default=_lazy(u'Unknown')):
 
 @register.function
 def date_ago(days=0):
-    now = datetime.now()
-    diff = timedelta(days=days)
+    now = datetime.datetime.now()
+    diff = datetime.timedelta(days=days)
     return (now - diff).date()
 
 

fjord/base/middleware.py

@@ -1,6 +1,15 @@
+import urllib
+from warnings import warn
+
 from django.conf import settings
+from django.http import HttpResponsePermanentRedirect
+from django.utils.encoding import smart_str
+
+import tower
 
+from fjord.base import urlresolvers
 from fjord.base.browsers import parse_ua
+from fjord.base.helpers import urlparams
 
 
 """
@@ -97,3 +106,61 @@ def process_response(self, request, response):
             cookie_value = request.MOBILE_SET_COOKIE
             response.set_cookie(MOBILE_COOKIE, cookie_value)
         return response
+
+
+class LocaleURLMiddleware(object):
+    """
+    1. Search for the locale.
+    2. Save it in the request.
+    3. Strip them from the URL.
+    """
+
+    def __init__(self):
+        if not settings.USE_I18N or not settings.USE_L10N:
+            warn("USE_I18N or USE_L10N is False but LocaleURLMiddleware is "
+                 "loaded. Consider removing fjord.base.middleware."
+                 "LocaleURLMiddleware from your MIDDLEWARE_CLASSES setting.")
+
+        self.exempt_urls = getattr(settings, 'FF_EXEMPT_LANG_PARAM_URLS', ())
+
+    def _is_lang_change(self, request):
+        """Return True if the lang param is present and URL isn't exempt."""
+        if 'lang' not in request.GET:
+            return False
+
+        return not any(request.path.endswith(url) for url in self.exempt_urls)
+
+    def process_request(self, request):
+        prefixer = urlresolvers.Prefixer(request)
+        urlresolvers.set_url_prefix(prefixer)
+        full_path = prefixer.fix(prefixer.shortened_path)
+
+        if self._is_lang_change(request):
+            # Blank out the locale so that we can set a new one. Remove lang
+            # from the query params so we don't have an infinite loop.
+            prefixer.locale = ''
+            new_path = prefixer.fix(prefixer.shortened_path)
+            query = dict((smart_str(k), request.GET[k]) for k in request.GET)
+            query.pop('lang')
+            return HttpResponsePermanentRedirect(urlparams(new_path, **query))
+
+        if full_path != request.path:
+            query_string = request.META.get('QUERY_STRING', '')
+            full_path = urllib.quote(full_path.encode('utf-8'))
+
+            if query_string:
+                full_path = '%s?%s' % (full_path, query_string)
+
+            response = HttpResponsePermanentRedirect(full_path)
+
+            # Vary on Accept-Language if we changed the locale
+            old_locale = prefixer.locale
+            new_locale, _ = urlresolvers.split_path(full_path)
+            if old_locale != new_locale:
+                response['Vary'] = 'Accept-Language'
+
+            return response
+
+        request.path_info = '/' + prefixer.shortened_path
+        request.locale = prefixer.locale
+        tower.activate(prefixer.locale)

fjord/base/monkeypatches.py

@@ -0,0 +1,46 @@
+import logging
+
+
+__all__ = ['patch']
+
+
+# Prevent from patching twice.
+_has_patched = False
+
+
+def patch():
+    global _has_patched
+    if _has_patched:
+        return
+
+    # Import for side-effect: configures logging handlers.
+    from fjord.settings.log_settings import noop
+    noop()
+
+    # Monkey-patch admin site.
+    from django.contrib import admin
+    from django.contrib.auth.decorators import login_required
+    from session_csrf import anonymous_csrf
+    from adminplus import AdminSitePlus
+
+    admin.site = AdminSitePlus()
+    admin.autodiscover()
+    admin.site.login = login_required(anonymous_csrf(admin.site.login))
+
+    # Monkey-patch django forms to avoid having to use Jinja2's |safe
+    # everywhere.
+    import jingo.monkey
+    jingo.monkey.patch()
+
+    # Monkey-patch Django's csrf_protect decorator to use
+    # session-based CSRF tokens.
+    import session_csrf
+    session_csrf.monkeypatch()
+
+    from jingo import load_helpers
+    load_helpers()
+
+    logging.debug("Note: monkey patches executed in %s" % __file__)
+
+    # Prevent it from being run again later.
+    _has_patched = True

fjord/base/tests/__init__.py

@@ -17,9 +17,9 @@
 
 import factory
 # reverse is here for convenience so other test modules import it from
-# here rather than importing it from funfactory
-from funfactory.urlresolvers import reverse  # noqa
-from funfactory.urlresolvers import split_path
+# here rather than importing it from urlresolvers
+from fjord.base.urlresolvers import reverse  # noqa
+from fjord.base.urlresolvers import split_path
 
 from fjord.base.models import Profile