Ticket #14693: 14693.2.diff

django/conf/global_settings.py

@@ -195 +195 @@
     'django.core.context_processors.debug',
     'django.core.context_processors.i18n',
     'django.core.context_processors.media',
+    'django.core.context_processors.static',
 #    'django.core.context_processors.request',
     'django.contrib.messages.context_processors.messages',
-    'django.contrib.staticfiles.context_processors.staticfiles',
 )
 
 # Output to use in template system for invalid (e.g. misspelled) variables.
@@ -263 +263 @@
 # Example: "http://media.lawrence.com"
 MEDIA_URL = ''
 
+# Absolute path to the directory that holds static files.
+# Example: "/home/media/media.lawrence.com/static/"
+STATIC_ROOT = ''
+
+# URL that handles the static files served from STATIC_ROOT.
+# Example: "http://media.lawrence.com/static/"
+STATIC_URL = ''
+
 # List of upload handler classes to be applied in order.
 FILE_UPLOAD_HANDLERS = (
     'django.core.files.uploadhandler.MemoryFileUploadHandler',
@@ -552 +560 @@
 # STATICFILES #
 ###############
 
-# Absolute path to the directory that holds media.
-# Example: "/home/media/media.lawrence.com/static/"
-STATICFILES_ROOT = ''
-
-# URL that handles the static files served from STATICFILES_ROOT.
-# Example: "http://media.lawrence.com/static/"
-STATICFILES_URL = '/static/'
-
 # A list of locations of additional static files
 STATICFILES_DIRS = ()
 

django/conf/project_template/settings.py

@@ -54 +54 @@
 
 # Absolute path to the directory that holds media.
 # Example: "/home/media/media.lawrence.com/static/"
-STATICFILES_ROOT = ''
+STATIC_ROOT = ''
 
-# URL that handles the static files served from STATICFILES_ROOT.
+# URL that handles the static files served from STATIC_ROOT.
 # Example: "http://static.lawrence.com/", "http://example.com/static/"
-STATICFILES_URL = '/static/'
+STATIC_URL = '/static/'
 
 # URL prefix for admin media -- CSS, JavaScript and images.
 # Make sure to use a trailing slash.

django/contrib/admin/templatetags/adminmedia.py

@@ -1 +1 @@
 from django.template import Library
-from django.utils.encoding import iri_to_uri
+from django.templatetags.static import PrefixNode
 
 register = Library()
 
+@register.simple_tag
 def admin_media_prefix():
     """
     Returns the string contained in the setting ADMIN_MEDIA_PREFIX.
     """
-    try:
-        from django.conf import settings
-    except ImportError:
-        return ''
-    return iri_to_uri(settings.ADMIN_MEDIA_PREFIX)
-admin_media_prefix = register.simple_tag(admin_media_prefix)
+    return PrefixNode.get_prefix("ADMIN_MEDIA_PREFIX")

deleted file django/contrib/staticfiles/context_processors.py

@@ -1 @@
-from django.conf import settings
-
-def staticfiles(request):
-    return {
-        'STATICFILES_URL': settings.STATICFILES_URL,
-    }

django/contrib/staticfiles/handlers.py

@@ -10 +10 @@
 class StaticFilesHandler(WSGIHandler):
     """
     WSGI middleware that intercepts calls to the static files directory, as
-    defined by the STATICFILES_URL setting, and serves those files.
+    defined by the STATIC_URL setting, and serves those files.
     """
-    def __init__(self, application, media_dir=None):
+    def __init__(self, application, base_dir=None):
         self.application = application
-        if media_dir:
-            self.media_dir = media_dir
+        if base_dir:
+            self.base_dir = base_dir
         else:
-            self.media_dir = self.get_media_dir()
-        self.media_url = urlparse(self.get_media_url())
+            self.base_dir = self.get_base_dir()
+        self.base_url = urlparse(self.get_base_url())
         if settings.DEBUG:
             utils.check_settings()
         super(StaticFilesHandler, self).__init__()
 
-    def get_media_dir(self):
-        return settings.STATICFILES_ROOT
+    def get_base_dir(self):
+        return settings.STATIC_ROOT
 
-    def get_media_url(self):
-        return settings.STATICFILES_URL
+    def get_base_url(self):
+        return settings.STATIC_URL
 
     def _should_handle(self, path):
         """
         Checks if the path should be handled. Ignores the path if:
 
-        * the host is provided as part of the media_url
+        * the host is provided as part of the base_url
         * the request's path isn't under the media path (or equal)
         * settings.DEBUG isn't True
         """
-        return (self.media_url[2] != path and
-            path.startswith(self.media_url[2]) and not self.media_url[1])
+        return (self.base_url[2] != path and
+            path.startswith(self.base_url[2]) and not self.base_url[1])
 
     def file_path(self, url):
         """
         Returns the relative path to the media file on disk for the given URL.
 
-        The passed URL is assumed to begin with ``media_url``.  If the
+        The passed URL is assumed to begin with ``base_url``.  If the
         resultant file path is outside the media directory, then a ValueError
         is raised.
         """
-        # Remove ``media_url``.
-        relative_url = url[len(self.media_url[2]):]
+        relative_url = url[len(self.base_url[2]):]
         return urllib.url2pathname(relative_url)
 
     def serve(self, request):

django/contrib/staticfiles/management/commands/collectstatic.py

@@ -12 +12 @@
 class Command(NoArgsCommand):
     """
     Command that allows to copy or symlink media files from different
-    locations to the settings.STATICFILES_ROOT.
+    locations to the settings.STATIC_ROOT.
     """
     option_list = NoArgsCommand.option_list + (
         make_option('--noinput', action='store_false', dest='interactive',
@@ -85 +85 @@
             self.stdout.write("\n%s static file%s %s to '%s'%s.\n"
                               % (actual_count, actual_count != 1 and 's' or '',
                                  symlink and 'symlinked' or 'copied',
-                                 settings.STATICFILES_ROOT,
+                                 settings.STATIC_ROOT,
                                  unmodified_count and ' (%s unmodified)'
                                  % unmodified_count or ''))
 

django/contrib/staticfiles/management/commands/runserver.py

@@ -8 +8 @@
 class Command(BaseRunserverCommand):
     option_list = BaseRunserverCommand.option_list + (
         make_option('--nostatic', action="store_false", dest='use_static_handler', default=True,
-            help='Tells Django to NOT automatically serve static files at STATICFILES_URL.'),
+            help='Tells Django to NOT automatically serve static files at STATIC_URL.'),
         make_option('--insecure', action="store_true", dest='insecure_serving', default=False,
             help='Allows serving static files even if DEBUG is False.'),
     )

django/contrib/staticfiles/storage.py

@@ -12 +12 @@
     Standard file system storage for site media files.
     
     The defaults for ``location`` and ``base_url`` are
-    ``STATICFILES_ROOT`` and ``STATICFILES_URL``.
+    ``STATIC_ROOT`` and ``STATIC_URL``.
     """
     def __init__(self, location=None, base_url=None, *args, **kwargs):
         if location is None:
-            location = settings.STATICFILES_ROOT
+            location = settings.STATIC_ROOT
         if base_url is None:
-            base_url = settings.STATICFILES_URL
+            base_url = settings.STATIC_URL
         if not location:
             raise ImproperlyConfigured("You're using the staticfiles app "
-                "without having set the STATICFILES_ROOT setting. Set it to "
+                "without having set the STATIC_ROOT setting. Set it to "
                 "the absolute path of the directory that holds static media.")
         if not base_url:
             raise ImproperlyConfigured("You're using the staticfiles app "
-                "without having set the STATICFILES_URL setting. Set it to "
-                "URL that handles the files served from STATICFILES_ROOT.")
+                "without having set the STATIC_URL setting. Set it to "
+                "URL that handles the files served from STATIC_ROOT.")
         if settings.DEBUG:
             utils.check_settings()
         super(StaticFilesStorage, self).__init__(location, base_url, *args, **kwargs)

deleted file django/contrib/staticfiles/templatetags/staticfiles.py

@@ -1 @@
-from django import template
-from django.utils.encoding import iri_to_uri
-
-register = template.Library()
-
-class StaticFilesPrefixNode(template.Node):
-
-    def __init__(self, varname=None):
-        self.varname = varname
-
-    def render(self, context):
-        try:
-            from django.conf import settings
-        except ImportError:
-            prefix = ''
-        else:
-            prefix = iri_to_uri(settings.STATICFILES_URL)
-        if self.varname is None:
-            return prefix
-        context[self.varname] = prefix
-        return ''
-
-@register.tag
-def get_staticfiles_prefix(parser, token):
-    """
-    Populates a template variable with the prefix (settings.STATICFILES_URL).
-
-    Usage::
-
-        {% get_staticfiles_prefix [as varname] %}
-
-    Examples::
-
-        {% get_staticfiles_prefix %}
-        {% get_staticfiles_prefix as staticfiles_prefix %}
-
-    """
-    tokens = token.contents.split()
-    if len(tokens) > 1 and tokens[1] != 'as':
-        raise template.TemplateSyntaxError(
-            "First argument in '%s' must be 'as'" % tokens[0])
-    return StaticFilesPrefixNode(varname=(len(tokens) > 1 and tokens[2] or None))
-

django/contrib/staticfiles/urls.py

@@ -18 +18 @@
     if not settings.DEBUG:
         return []
     if prefix is None:
-        prefix = settings.STATICFILES_URL
-    if not prefix:
+        prefix = settings.STATIC_URL
+    if not prefix or '://' in prefix:
         raise ImproperlyConfigured(
-            "The prefix for the 'staticfiles_urlpatterns' helper is empty. "
-            "Make sure the STATICFILES_URL setting is set correctly.")
-    if '://' in prefix:
-        raise ImproperlyConfigured(
-            "The STATICFILES_URL setting is a full URL, not a path and "
-            "can't be used with the 'staticfiles_urlpatterns' helper.")
+            "The prefix for the 'staticfiles_urlpatterns' helper is invalid.")
     if prefix.startswith("/"):
         prefix = prefix[1:]
     return patterns('',

django/contrib/staticfiles/utils.py

@@ -33 +33 @@
 
 def check_settings():
     """
-    Checks if the MEDIA_(ROOT|URL) and STATICFILES_(ROOT|URL)
+    Checks if the MEDIA_(ROOT|URL) and STATIC_(ROOT|URL)
     settings have the same value.
     """
-    if settings.MEDIA_URL == settings.STATICFILES_URL:
-        raise ImproperlyConfigured("The MEDIA_URL and STATICFILES_URL "
+    if settings.MEDIA_URL == settings.STATIC_URL:
+        raise ImproperlyConfigured("The MEDIA_URL and STATIC_URL "
                                    "settings must have individual values")
-    if ((settings.MEDIA_ROOT and settings.STATICFILES_ROOT) and
-            (settings.MEDIA_ROOT == settings.STATICFILES_ROOT)):
-        raise ImproperlyConfigured("The MEDIA_ROOT and STATICFILES_ROOT "
+    if ((settings.MEDIA_ROOT and settings.STATIC_ROOT) and
+            (settings.MEDIA_ROOT == settings.STATIC_ROOT)):
+        raise ImproperlyConfigured("The MEDIA_ROOT and STATIC_ROOT "
                                    "settings must have individual values")

django/core/context_processors.py

@@ -66 +66 @@
 
     return context_extras
 
+def static(request):
+    """
+    Adds static-related context variables to the context.
+
+    """
+    return {'STATIC_URL': settings.STATIC_URL}
+
 def media(request):
     """
     Adds media-related context variables to the context.

django/core/servers/basehttp.py

@@ -643 +643 @@
     security and is not super efficient.
     """
 
-    def get_media_dir(self):
+    def get_base_dir(self):
         import django
         return os.path.join(django.__path__[0], 'contrib', 'admin', 'media')
 
-    def get_media_url(self):
+    def get_base_url(self):
         from django.conf import settings
         return settings.ADMIN_MEDIA_PREFIX
 
@@ -660 +660 @@
         is raised.
         """
         # Remove ``media_url``.
-        relative_url = url[len(self.media_url[2]):]
+        relative_url = url[len(self.base_url[2]):]
         relative_path = urllib.url2pathname(relative_url)
-        return safe_join(self.media_dir, relative_path)
+        return safe_join(self.base_dir, relative_path)
 
     def serve(self, request):
         document_root, path = os.path.split(self.file_path(request.path))
@@ -673 +673 @@
         """
         Checks if the path should be handled. Ignores the path if:
 
-        * the host is provided as part of the media_url
-        * the request's path isn't under the media path
+        * the host is provided as part of the base_url
+        * the request's path isn't under the base path
         """
-        return path.startswith(self.media_url[2]) and not self.media_url[1]
+        return path.startswith(self.base_url[2]) and not self.base_url[1]
 
 
 def run(addr, port, wsgi_handler):

django/forms/widgets.py

@@ -1 +1 @@
 """
 HTML Widget classes
 """
+import datetime
+from itertools import chain
+import time
+from urlparse import urljoin
+from util import flatatt
 
 import django.utils.copycompat as copy
-from itertools import chain
 from django.conf import settings
 from django.utils.datastructures import MultiValueDict, MergeDict
 from django.utils.html import escape, conditional_escape
@@ -11 +15 @@
 from django.utils.encoding import StrAndUnicode, force_unicode
 from django.utils.safestring import mark_safe
 from django.utils import datetime_safe, formats
-import time
-import datetime
-from util import flatatt
-from urlparse import urljoin
 
 __all__ = (
     'Media', 'MediaDefiningClass', 'Widget', 'TextInput', 'PasswordInput',
@@ -63 +63 @@
                     for path in self._css[medium]]
                 for medium in media])
 
-    def absolute_path(self, path):
+    def absolute_path(self, path, prefix=None):
         if path.startswith(u'http://') or path.startswith(u'https://') or path.startswith(u'/'):
             return path
-        return urljoin(settings.MEDIA_URL,path)
+        if prefix is None:
+            if settings.STATIC_URL:
+                prefix = settings.STATIC_URL
+            else:
+                 # backwards compatibility
+                prefix = settings.MEDIA_URL
+        return urljoin(prefix, path)
 
     def __getitem__(self, name):
         "Returns a Media object that only contains media of the given type"

new file django/templatetags/static.py

@@ +1 @@
+from django import template
+from django.utils.encoding import iri_to_uri
+
+register = template.Library()
+
+class PrefixNode(template.Node):
+
+    def __repr__(self):
+        return "<PrefixNode for %r>" % self.name
+
+    def __init__(self, varname=None, name=None):
+        if name is None:
+            raise template.TemplateSyntaxError(
+                "Prefix nodes must be given a name to return.")
+        self.varname = varname
+        self.name = name
+
+    @classmethod
+    def handle_token(cls, parser, token, name):
+        """
+        Class method to parse prefix node and return a Node.
+        """
+        tokens = token.contents.split()
+        if len(tokens) > 1 and tokens[1] != 'as':
+            raise template.TemplateSyntaxError(
+                "First argument in '%s' must be 'as'" % tokens[0])
+        if len(tokens) > 1:
+            varname = tokens[2]
+        else:
+            varname = None
+        return cls(varname, name)
+
+    @classmethod
+    def get_prefix(cls, name):
+        try:
+            from django.conf import settings
+        except ImportError:
+            prefix = ''
+        else:
+            prefix = iri_to_uri(getattr(settings, name, ''))
+        return prefix
+
+    def render(self, context):
+        prefix = self.get_prefix(self.name)
+        if self.varname is None:
+            return prefix
+        context[self.varname] = prefix
+        return ''
+
+@register.tag
+def get_static_prefix(parser, token):
+    """
+    Populates a template variable with the static prefix,
+    ``settings.STATIC_URL``.
+
+    Usage::
+
+        {% get_static_prefix [as varname] %}
+
+    Examples::
+
+        {% get_static_prefix %}
+        {% get_static_prefix as static_prefix %}
+
+    """
+    return PrefixNode.handle_token(parser, token, "STATIC_URL")
+
+@register.tag
+def get_media_prefix(parser, token):
+    """
+    Populates a template variable with the static prefix,
+    ``settings.MEDIA_URL``.
+
+    Usage::
+
+        {% get_media_prefix [as varname] %}
+
+    Examples::
+
+        {% get_media_prefix %}
+        {% get_media_prefix as media_prefix %}
+
+    """
+    return PrefixNode.handle_token(parser, token, "MEDIA_URL")

docs/howto/static-files.txt

@@ -50 +50 @@
        First, you'll need to make sure that ``django.contrib.staticfiles`` is in
        your :setting:`INSTALLED_APPS`.
 
-       Next, you'll need to edit :setting:`STATICFILES_ROOT` to point to where
+       Next, you'll need to edit :setting:`STATIC_ROOT` to point to where
        you'd like your static media stored. For example::
 
-            STATICFILES_ROOT = "/home/jacob/projects/mysite.com/static_media"
+            STATIC_ROOT = "/home/jacob/projects/mysite.com/static_media"
 
-       You may also want to set the :setting:`STATICFILES_URL` setting at this
+       You may also want to set the :setting:`STATIC_URL` setting at this
        time, though the default value (of ``/static/``) is perfect for local
        development.
 
@@ -69 +69 @@
             ./manage.py collectstatic
 
        This'll churn through your static file storage and move them into the
-       directory given by :setting:`STATICFILES_ROOT`. (This is not necessary
+       directory given by :setting:`STATIC_ROOT`. (This is not necessary
        in local development if you are using :djadmin:`runserver` or adding
        ``staticfiles_urlpatterns`` to your URLconf; see below).
 
@@ -78 +78 @@
        If you're using the built-in development server (the
        :djadmin:`runserver` management command) and have the :setting:`DEBUG`
        setting set to ``True``, your staticfiles will automatically be served
-       from :setting:`STATICFILES_URL` in development.
+       from :setting:`STATIC_URL` in development.
 
        If you are using some other server for local development, you can
        quickly serve static media locally by adding::
@@ -98 +98 @@
 
           .. code-block:: html+django
 
-               <img src="{{ STATICFILES_URL }}images/hi.jpg />
+               <img src="{{ STATIC_URL }}images/hi.jpg />
 
        See :ref:`staticfiles-in-templates` for more details, including an
        alternate method (using a template tag).
@@ -115 +115 @@
    app is to make it easier to keep static files separate from user-uploaded
    files. For this reason, you will probably want to make your
    :setting:`MEDIA_ROOT` and :setting:`MEDIA_URL` different from your
-   :setting:`STATICFILES_ROOT` and :setting:`STATICFILES_URL`. You will need to
+   :setting:`STATIC_ROOT` and :setting:`STATIC_URL`. You will need to
    arrange for serving of files in :setting:`MEDIA_ROOT` yourself;
    ``staticfiles`` does not deal with user-uploaded media at all.
 
@@ -136 +136 @@
 media. If, for example, you wanted to switch to using a content delivery network
 (CDN), then you'd need to change more or less every single template.
 
-A far better way is to use the value of the :setting:`STATICFILES_URL` setting
+A far better way is to use the value of the :setting:`STATIC_URL` setting
 directly in your templates. This means that a switch of media servers only
 requires changing that single value. Much better!
 
@@ -147 +147 @@
 ------------------------
 
 The included context processor is the easy way. Simply make sure
-``'django.contrib.staticfiles.context_processors.staticfiles'`` is in your
+``'django.core.context_processors.static'`` is in your
 :setting:`TEMPLATE_CONTEXT_PROCESSORS`. It's there by default, and if you're
 editing that setting by hand it should look something like::
 
@@ -155 +155 @@
         'django.core.context_processors.debug',
         'django.core.context_processors.i18n',
         'django.core.context_processors.media',
+        'django.core.context_processors.static',
         'django.contrib.auth.context_processors.auth',
         'django.contrib.messages.context_processors.messages',
-        'django.contrib.staticfiles.context_processors.staticfiles',
     )
 
-Once that's done, you can refer to :setting:`STATICFILES_URL` in your templates:
+Once that's done, you can refer to :setting:`STATIC_URL` in your templates:
 
 .. code-block:: html+django
 
-     <img src="{{ STATICFILES_URL }}images/hi.jpg />
+     <img src="{{ STATIC_URL }}images/hi.jpg />
 
-If ``{{ STATICFILES_URL }}`` isn't working in your template, you're probably not
+If ``{{ STATIC_URL }}`` isn't working in your template, you're probably not
 using :class:`~django.template.RequestContext` when rendering the template.
 
 As a brief refresher, context processors add variables into the contexts of
@@ -180 +180 @@
 With a template tag
 -------------------
 
-The second option is the :ttag:`get_staticfiles_prefix` template tag. You can
+The second option is the :ttag:`get_static_prefix` template tag. You can
 use this if you're not using :class:`~django.template.RequestContext`, or if you
-need more control over exactly where and how :setting:`STATICFILES_URL` is
+need more control over exactly where and how :setting:`STATIC_URL` is
 injected into the template. Here's an example:
 
 .. code-block:: html+django
 
-    {% load staticfiles %}
-    <img src="{% get_staticfiles_prefix %}images/hi.jpg" />
+    {% load static %}
+    <img src="{% get_static_prefix %}images/hi.jpg" />
 
 There's also a second form you can use to avoid extra processing if you need the
 value multiple times:
 
 .. code-block:: html+django
 
-    {% load staticfiles %}
-    {% get_staticfiles_prefix as STATIC_PREFIX %}
+    {% load static %}
+    {% get_static_prefix as STATIC_PREFIX %}
 
     <img src="{{ STATIC_PREFIX }}images/hi.jpg" />
     <img src="{{ STATIC_PREFIX }}images/hi2.jpg" />
@@ -213 +213 @@
 can use to serve files locally in development.
 
 This view is automatically enabled and will serve your static files at
-:setting:`STATICFILES_URL` when you use the built-in :djadmin:`runserver`.
+:setting:`STATIC_URL` when you use the built-in :djadmin:`runserver`.
 
 To enable this view if you are using some other server for local development,
 you'll add a couple of lines to your URLconf. The first line goes at the top of
@@ -225 +225 @@
 
     urlpatterns += staticfiles_urlpatterns()
 
-This will inspect your :setting:`STATICFILES_URL` and
-:setting:`STATICFILES_ROOT` settings and wire up the view to serve static media
+This will inspect your :setting:`STATIC_URL` and
+:setting:`STATIC_ROOT` settings and wire up the view to serve static media
 accordingly. Don't forget to set the :setting:`STATICFILES_DIRS` setting
 appropriately to let ``django.contrib.staticfiles`` know where to look for
-files.
+(additional) files.
 
 .. warning::
 
@@ -239 +239 @@
     **insecure**. This is only intended for local development, and should
     **never be used in production**.
 
+    Additionally, your :setting:`STATIC_URL` setting can't be either empty
+    or a full URL such as ``http://static.example.com/``.
+
 For a few more details, including an alternate method of enabling this view,
 see :ref:`staticfiles-development-view`.
 
@@ -249 +252 @@
 
 The basic outline of putting static files into production is simple: run the
 :djadmin:`collectstatic` command when static media changes, then arrange for the
-collected media directory (:setting:`STATICFILES_ROOT`) to be moved to the media
+collected media directory (:setting:`STATIC_ROOT`) to be moved to the media
 server and served.
 
 Of course, as with all deployment tasks, the devil's in the details. Every
@@ -264 +267 @@
 
     * Push your code up to the deployment server.
     * On the server, run :djadmin:`collectstatic` to move all the media into
-      :setting:`STATICFILES_ROOT`.
-    * Point your web server at :setting:`STATICFILES_ROOT`. For example, here's
+      :setting:`STATIC_ROOT`.
+    * Point your web server at :setting:`STATIC_ROOT`. For example, here's
       :ref:`how to do this under Apache and mod_wsgi <serving-media-files>`.
 
 You'll probably want to automate this process, especially if you've got multiple
@@ -322 +325 @@
 deployment strategy to look something like:
 
     * When your media changes, run :djadmin:`collectstatic` locally.
-    * Push your local :setting:`STATICFILES_ROOT` up to the media server
+    * Push your local :setting:`STATIC_ROOT` up to the media server
       into the directory that's being served. ``rsync`` is a good
       choice for this step since it only needs to transfer the
       bits of static media that have changed.
@@ -403 +406 @@
     * The management commands ``build_static`` and ``resolve_static`` are now
       called :djadmin:`collectstatic` and :djadmin:`findstatic`.
 
-    * The settings ``STATIC_URL`` and ``STATIC_ROOT`` were renamed to
-      :setting:`STATICFILES_URL` and :setting:`STATICFILES_ROOT`.
-
     * The settings ``STATICFILES_PREPEND_LABEL_APPS``,
       ``STATICFILES_MEDIA_DIRNAMES`` and ``STATICFILES_EXCLUDED_APPS`` were
       removed.

docs/man/django-admin.1

@@ -165 +165 @@
 Disable the development server's auto\-reloader.
 .TP
 .I \-\-nostatic
-Disable automatic serving of static files from STATICFILES_URL.
+Disable automatic serving of static files from STATIC_URL.
 .TP
 .I \-\-insecure
 Enables serving of static files even if DEBUG is False.

docs/ref/contrib/staticfiles.txt

@@ -23 +23 @@
 
 .. highlight:: python
 
-The following settings control the behavior of the staticfiles app. Only
-:setting:`STATICFILES_ROOT` is required, but you'll probably also need to
-configure :setting:`STATICFILES_URL` as well.
-
-.. setting:: STATICFILES_ROOT
-
-STATICFILES_ROOT
-----------------
-
-Default: ``''`` (Empty string)
-
-The absolute path to the directory that the :djadmin:`collectstatic` management
-command will collect static files into, for serving from
-:setting:`STATICFILES_URL`::
-
-   STATICFILES_ROOT = "/home/example.com/static/"
-
-This is a **required setting** unless you've overridden
-:setting:`STATICFILES_STORAGE` and are using a custom storage backend.
-
-This is not a place to store your static files permanently under version
-control; you should do that in directories that will be found by your
-:setting:`STATICFILES_FINDERS` (by default, per-app ``static/`` subdirectories,
-and any directories you include in :setting:`STATICFILES_DIRS`). Files from
-those locations will be collected into :setting:`STATICFILES_ROOT`.
-
-.. setting:: STATICFILES_URL
-
-STATICFILES_URL
----------------
-
-Default: ``'/static/'``
-
-The URL that handles the files served from :setting:`STATICFILES_ROOT`, e.g.::
-
-    STATICFILES_URL = '/site_media/static/'
-
-... or perhaps::
-
-    STATICFILES_URL = 'http://static.example.com/'
+.. note::
 
-This should **always** have a trailing slash.
+    The following settings control the behavior of the staticfiles app.
+    Configuring the global settings :setting:`STATIC_ROOT` and
+    :setting:`STATIC_URL` is **required**.
 
 .. setting:: STATICFILES_DIRS
 
@@ -98 +61 @@
 
 With this configuration, the :djadmin:`collectstatic` management command would
 for example collect the stats files in a ``'downloads'`` directory. So
-assuming you have :setting:`STATICFILES_URL` set ``'/static/'``, this would
+assuming you have :setting:`STATIC_URL` set ``'/static/'``, this would
 allow you to refer to the file ``'/opt/webfiles/stats/polls_20101022.tar.gz'``
 with ``'/static/downloads/polls_20101022.tar.gz'`` in your templates.
 
@@ -160 +123 @@
 
 .. django-admin:: collectstatic
 
-Collects the static files into :setting:`STATICFILES_ROOT`.
+Collects the static files into :setting:`STATIC_ROOT`.
 
 Duplicate file names are by default resolved in a similar way to how template
 resolution works: the file that is first found in one of the specified
@@ -223 +186 @@
 Other Helpers
 =============
 
-The ``staticfiles`` context processor
--------------------------------------
+The ``static`` context processor
+--------------------------------
 
-.. function:: django.contrib.staticfiles.context_processors.staticfiles
+.. function:: django.core.context_processors.static
 
-This context processor adds the :setting:`STATICFILES_URL` into each template
-context as the variable ``{{ STATICFILES_URL }}``. To use it, make sure that
-``'django.contrib.staticfiles.context_processors.staticfiles'`` appears
-somewhere in your :setting:`TEMPLATE_CONTEXT_PROCESSORS` setting.
+This context processor adds the :setting:`STATIC_URL` into each template
+context as the variable ``{{ STATIC_URL }}``. To use it, make sure that
+``'django.core.context_processors.static'`` appears somewhere in your
+:setting:`TEMPLATE_CONTEXT_PROCESSORS` setting.
 
 Remember, only templates rendered with :class:`~django.template.RequestContext`
 will have acces to the data provided by this (and any) context processor.
 
-.. templatetag:: get_staticfiles_prefix
+.. templatetag:: get_static_prefix
 
-The ``get_staticfiles_prefix`` templatetag
-==========================================
+The ``get_static_prefix`` templatetag
+=====================================
 
 .. highlight:: html+django
 
 If you're not using :class:`~django.template.RequestContext`, or if you need
-more control over exactly where and how :setting:`STATICFILES_URL` is injected
-into the template, you can use the :ttag:`get_staticfiles_prefix` template tag
+more control over exactly where and how :setting:`STATIC_URL` is injected
+into the template, you can use the :ttag:`get_static_prefix` template tag
 instead::
 
-    {% load staticfiles %}
-    <img src="{% get_staticfiles_prefix %}images/hi.jpg" />
+    {% load static %}
+    <img src="{% get_static_prefix %}images/hi.jpg" />
 
 There's also a second form you can use to avoid extra processing if you need
 the value multiple times::
 
-    {% load staticfiles %}
-    {% get_staticfiles_prefix as STATIC_PREFIX %}
+    {% load static %}
+    {% get_static_prefix as STATIC_PREFIX %}
 
     <img src="{{ STATIC_PREFIX }}images/hi.jpg" />
     <img src="{{ STATIC_PREFIX }}images/hi2.jpg" />
@@ -292 +255 @@
        )
 
 Note, the begin of the pattern (``r'^static/'``) should be your
-:setting:`STATICFILES_URL` setting.
+:setting:`STATIC_URL` setting.
 
 Since this is a bit finicky, there's also a helper function that'll do this for you:
 
@@ -307 +270 @@
 
    urlpatterns += staticfiles_urlpatterns()
 
+.. warning::
+
+    This helper function will only work if :setting:`DEBUG` is ``True``
+    and your :setting:`STATIC_URL` setting is neither empty nor a full
+    URL such as ``http://static.example.com/``.

docs/ref/settings.txt

@@ -56 +56 @@
 different from the :setting:``MEDIA_URL`` setting (since the same URL cannot be
 mapped onto two different sets of files). For integration with :doc:`staticfiles
 </ref/contrib/staticfiles>`, this should be the same as
-:setting:`STATICFILES_URL` followed by ``'admin/'``.
+:setting:`STATIC_URL` followed by ``'admin/'``.
 
 .. setting:: ADMINS
 
@@ -1122 +1122 @@
 URL that handles the media served from :setting:`MEDIA_ROOT`, used
 for :doc:`managing stored files </topics/files>`.
 
-Example: ``"http://media.lawrence.com"``
+Example: ``"http://media.lawrence.com/"``
 
 Note that this should have a trailing slash if it has a path component.
 
- * Good: ``"http://www.example.com/static/"``
- * Bad: ``"http://www.example.com/static"``
+ * Good: ``"http://www.example.com/media/"``
+ * Bad: ``"http://www.example.com/media"``
 
 MESSAGE_LEVEL
 -------------
@@ -1486 +1486 @@
 
 .. _site framework docs: ../sites/
 
+.. setting:: STATIC_ROOT
+
+STATIC_ROOT
+-----------
+
+Default: ``''`` (Empty string)
+
+The absolute path to the directory that contains static content.
+
+Example: ``"/home/example.com/static/"``
+
+When using the :djadmin:`collectstatic` management command of the optional,
+:doc:`staticfiles</ref/contrib/staticfiles>` app this will be used to collect
+static files into and served from :setting:`STATIC_URL`.
+
+In that case this is a **required setting**, unless you've overridden
+:setting:`STATICFILES_STORAGE` and are using a custom storage backend.
+
+This is not a place to store your static files permanently under version
+control; you should do that in directories that will be found by your
+:setting:`STATICFILES_FINDERS` (by default, per-app ``static/`` subdirectories,
+and any directories you include in :setting:`STATICFILES_DIRS`). Files from
+those locations will be collected into :setting:`STATIC_ROOT`.
+
+See :doc:`/ref/contrib/staticfiles` and :setting:`STATIC_URL`.
+
+.. setting:: STATIC_URL
+
+STATIC_URL
+----------
+
+Default: ``'/static/'``
+
+URL that handles the files served from :setting:`STATIC_ROOT`.
+
+Example: ``"/site_media/static/"`` or ``"http://static.example.com/"``
+
+This is used in the :doc:`staticfiles app</ref/contrib/staticfiles>`.
+
+See :setting:`STATIC_ROOT`.
+
 .. setting:: TEMPLATE_CONTEXT_PROCESSORS
 
 TEMPLATE_CONTEXT_PROCESSORS
@@ -1496 +1537 @@
     ("django.contrib.auth.context_processors.auth",
     "django.core.context_processors.debug",
     "django.core.context_processors.i18n",
-    "django.contrib.staticfiles.context_processors.staticfiles",
+    "django.core.context_processors.media",
+    "django.core.context_processors.static",
     "django.contrib.messages.context_processors.messages")
 
 A tuple of callables that are used to populate the context in ``RequestContext``.
@@ -1513 +1555 @@
     ``django.core.context_processors.auth`` to
     ``django.contrib.auth.context_processors.auth``.
 
+.. versionadded:: 1.3
+    The ``django.core.context_processors.static`` context processor
+    was added in this release.
+
 .. setting:: TEMPLATE_DEBUG
 
 TEMPLATE_DEBUG

docs/ref/templates/api.txt

@@ -312 +312 @@
     "django.core.context_processors.debug",
     "django.core.context_processors.i18n",
     "django.core.context_processors.media",
-    "django.contrib.messages.context_processors.messages",
-    "django.contrib.staticfiles.context_processors.staticfiles")
+    "django.core.context_processors.static",
+    "django.contrib.messages.context_processors.messages")
 
 .. versionadded:: 1.2
    In addition to these, ``RequestContext`` always uses
@@ -435 +435 @@
 ``RequestContext`` will contain a variable ``MEDIA_URL``, providing the
 value of the :setting:`MEDIA_URL` setting.
 
+django.core.context_processors.static
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. versionadded:: 1.3
+
+If :setting:`TEMPLATE_CONTEXT_PROCESSORS` contains this processor, every
+``RequestContext`` will contain a variable ``STATIC_URL``, providing the
+value of the :setting:`STATIC_URL` setting.
+
 django.core.context_processors.csrf
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

docs/releases/1.3.txt

@@ -59 +59 @@
 app is to make it easier to keep static files separate from user-uploaded
 files. For this reason, you will probably want to make your
 :setting:`MEDIA_ROOT` and :setting:`MEDIA_URL` different from your
-:setting:`STATICFILES_ROOT` and :setting:`STATICFILES_URL`. You will need to
+:setting:`STATIC_ROOT` and :setting:`STATIC_URL`. You will need to
 arrange for serving of files in :setting:`MEDIA_ROOT` yourself;
 ``staticfiles`` does not deal with user-uploaded media at all.
 

tests/regressiontests/staticfiles_tests/tests.py

@@ -23 +23 @@
     Test case with a couple utility assertions.
     """
     def setUp(self):
-        self.old_staticfiles_url = settings.STATICFILES_URL
-        self.old_staticfiles_root = settings.STATICFILES_ROOT
+        self.old_static_url = settings.STATIC_URL
+        self.old_static_root = settings.STATIC_ROOT
         self.old_staticfiles_dirs = settings.STATICFILES_DIRS
         self.old_staticfiles_finders = settings.STATICFILES_FINDERS
         self.old_media_root = settings.MEDIA_ROOT
@@ -40 +40 @@
         settings.DEBUG = True
         settings.MEDIA_ROOT =  os.path.join(site_media, 'media')
         settings.MEDIA_URL = '/media/'
-        settings.STATICFILES_ROOT = os.path.join(site_media, 'static')
-        settings.STATICFILES_URL = '/static/'
+        settings.STATIC_ROOT = os.path.join(site_media, 'static')
+        settings.STATIC_URL = '/static/'
         settings.ADMIN_MEDIA_PREFIX = '/static/admin/'
         settings.STATICFILES_DIRS = (
             os.path.join(TEST_ROOT, 'project', 'documents'),
@@ -52 +52 @@
             'django.contrib.staticfiles.finders.DefaultStorageFinder',
         )
         settings.INSTALLED_APPS = [
+            "django.contrib.staticfiles",
             "regressiontests.staticfiles_tests",
         ]
 
@@ -65 +66 @@
         settings.MEDIA_ROOT = self.old_media_root
         settings.MEDIA_URL = self.old_media_url
         settings.ADMIN_MEDIA_PREFIX = self.old_admin_media_prefix
-        settings.STATICFILES_ROOT = self.old_staticfiles_root
-        settings.STATICFILES_URL = self.old_staticfiles_url
+        settings.STATIC_ROOT = self.old_static_root
+        settings.STATIC_URL = self.old_static_url
         settings.STATICFILES_DIRS = self.old_staticfiles_dirs
         settings.STATICFILES_FINDERS = self.old_staticfiles_finders
         settings.INSTALLED_APPS = self.old_installed_apps
@@ -91 +92 @@
     def setUp(self):
         super(BuildStaticTestCase, self).setUp()
         self.old_staticfiles_storage = settings.STATICFILES_STORAGE
-        self.old_root = settings.STATICFILES_ROOT
-        settings.STATICFILES_ROOT = tempfile.mkdtemp()
+        self.old_root = settings.STATIC_ROOT
+        settings.STATIC_ROOT = tempfile.mkdtemp()
         self.run_collectstatic()
 
     def tearDown(self):
-        shutil.rmtree(settings.STATICFILES_ROOT)
-        settings.STATICFILES_ROOT = self.old_root
+        shutil.rmtree(settings.STATIC_ROOT)
+        settings.STATIC_ROOT = self.old_root
         super(BuildStaticTestCase, self).tearDown()
 
     def run_collectstatic(self, **kwargs):
@@ -106 +107 @@
 
     def _get_file(self, filepath):
         assert filepath, 'filepath is empty.'
-        filepath = os.path.join(settings.STATICFILES_ROOT, filepath)
+        filepath = os.path.join(settings.STATIC_ROOT, filepath)
         f = open(filepath)
         try:
             return f.read()
@@ -231 +232 @@
         """
         With --dry-run, no files created in destination dir.
         """
-        self.assertEquals(os.listdir(settings.STATICFILES_ROOT), [])
+        self.assertEquals(os.listdir(settings.STATIC_ROOT), [])
 
 
 if sys.platform != 'win32':
@@ -251 +252 @@
             With ``--link``, symbolic links are created.
 
             """
-            self.failUnless(os.path.islink(os.path.join(settings.STATICFILES_ROOT, 'test.txt')))
+            self.failUnless(os.path.islink(os.path.join(settings.STATIC_ROOT, 'test.txt')))
 
 
 class TestServeStatic(StaticFilesTestCase):
@@ -262 +263 @@
 
     def _response(self, filepath):
         return self.client.get(
-            posixpath.join(settings.STATICFILES_URL, filepath))
+            posixpath.join(settings.STATIC_URL, filepath))
 
     def assertFileContains(self, filepath, text):
         self.assertContains(self._response(filepath), text)
@@ -372 +373 @@
             finders.get_finder, "django.contrib.staticfiles.finders.FooBarFinder")
         self.assertRaises(ImproperlyConfigured,
             finders.get_finder, "foo.bar.FooBarFinder")
-
-
-class TemplateTagTest(TestCase):
-    def test_get_staticfiles_prefix(self):
-        """
-        Test the get_staticfiles_prefix helper return the STATICFILES_URL setting.
-        """
-        self.assertEquals(Template(
-            "{% load staticfiles %}"
-            "{% get_staticfiles_prefix %}"
-        ).render(Context()), settings.STATICFILES_URL)
-
-    def test_get_staticfiles_prefix_with_as(self):
-        """
-        Test the get_staticfiles_prefix helper return the STATICFILES_URL setting.
-        """
-        self.assertEquals(Template(
-            "{% load staticfiles %}"
-            "{% get_staticfiles_prefix as staticfiles_prefix %}"
-            "{{ staticfiles_prefix }}"
-        ).render(Context()), settings.STATICFILES_URL)

tests/regressiontests/templates/tests.py

@@ -114 +114 @@
         return u'ŠĐĆŽćžšđ'.encode('utf-8')
 
 class Templates(unittest.TestCase):
+    def setUp(self):
+        self.old_static_url = settings.STATIC_URL
+        self.old_media_url = settings.MEDIA_URL
+        settings.STATIC_URL = u"/static/"
+        settings.MEDIA_URL = u"/media/"
+
+    def tearDown(self):
+        settings.STATIC_URL = self.old_static_url
+        settings.MEDIA_URL = self.old_media_url
+
     def test_loaders_security(self):
         ad_loader = app_directories.Loader()
         fs_loader = filesystem.Loader()
@@ -1328 +1338 @@
             'autoescape-filtertag01': ("{{ first }}{% filter safe %}{{ first }} x<y{% endfilter %}", {"first": "<a>"}, template.TemplateSyntaxError),
 
             # ifqeual compares unescaped vales.
-            'autoescape-ifequal01': ('{% ifequal var "this & that" %}yes{% endifequal %}', { "var": "this & that" }, "yes" ),
+            'autoescape-ifequal01': ('{% ifequal var "this & that" %}yes{% endifequal %}', { "var": "this & that" }, "yes"),
 
             # Arguments to filters are 'safe' and manipulate their input unescaped.
             'autoescape-filters01': ('{{ var|cut:"&" }}', { "var": "this & that" }, "this  that" ),
-            'autoescape-filters02': ('{{ var|join:" & \" }}', { "var": ("Tom", "Dick", "Harry") }, "Tom & Dick & Harry" ),
+            'autoescape-filters02': ('{{ var|join:" & \" }}', { "var": ("Tom", "Dick", "Harry") }, "Tom & Dick & Harry"),
 
             # Literal strings are safe.
-            'autoescape-literals01': ('{{ "this & that" }}',{}, "this & that" ),
+            'autoescape-literals01': ('{{ "this & that" }}',{}, "this & that"),
 
             # Iterating over strings outputs safe characters.
-            'autoescape-stringiterations01': ('{% for l in var %}{{ l }},{% endfor %}', {'var': 'K&R'}, "K,&amp;,R," ),
+            'autoescape-stringiterations01': ('{% for l in var %}{{ l }},{% endfor %}', {'var': 'K&R'}, "K,&amp;,R,"),
 
             # Escape requirement survives lookup.
-            'autoescape-lookup01': ('{{ var.key }}', { "var": {"key": "this & that" }}, "this &amp; that" ),
+            'autoescape-lookup01': ('{{ var.key }}', { "var": {"key": "this & that" }}, "this &amp; that"),
 
+            # Static template tags
+            'static-prefixtag01': ('{% load static %}{% get_static_prefix %}', {}, settings.STATIC_URL),
+            'static-prefixtag02': ('{% load static %}{% get_static_prefix as static_prefix %}{{ static_prefix }}', {}, settings.STATIC_URL),
+            'static-prefixtag03': ('{% load static %}{% get_media_prefix %}', {}, settings.MEDIA_URL),
+            'static-prefixtag04': ('{% load static %}{% get_media_prefix as media_prefix %}{{ media_prefix }}', {}, settings.MEDIA_URL),
         }
 
-
 class TemplateTagLoading(unittest.TestCase):
 
     def setUp(self):