Ticket #14693: 14693.1.diff

File 14693.1.diff, 36.1 KB (added by Jannis Leidel, 15 years ago)

Initial patch

  • django/conf/global_settings.py 

    diff --git a/django/conf/global_settings.py b/django/conf/global_settings.py
index fab2d0f..8ebaba6 100644
    a b MEDIA_ROOT = ''  
    263263# Example: "http://media.lawrence.com"
    264264MEDIA_URL = ''
    265265
     266# Absolute path to the directory that holds static files.
     267# Example: "/home/media/media.lawrence.com/static/"
     268STATIC_ROOT = ''
     269
     270# URL that handles the static files served from STATIC_ROOT.
     271# Example: "http://media.lawrence.com/static/"
     272STATIC_URL = None
     273
    266274# List of upload handler classes to be applied in order.
    267275FILE_UPLOAD_HANDLERS = (
    268276    'django.core.files.uploadhandler.MemoryFileUploadHandler',
    … … FIXTURE_DIRS = ()  
    552560# STATICFILES #
    553561###############
    554562
    555 # Absolute path to the directory that holds media.
    556 # Example: "/home/media/media.lawrence.com/static/"
    557 STATICFILES_ROOT = ''
    558 
    559 # URL that handles the static files served from STATICFILES_ROOT.
    560 # Example: "http://media.lawrence.com/static/"
    561 STATICFILES_URL = '/static/'
    562 
    563563# A list of locations of additional static files
    564564STATICFILES_DIRS = ()
    565565

  • django/conf/project_template/settings.py 

    diff --git a/django/conf/project_template/settings.py b/django/conf/project_template/settings.py
index 07a823b..19d5ccd 100644
    a b MEDIA_URL = ''  
    5454
    5555# Absolute path to the directory that holds media.
    5656# Example: "/home/media/media.lawrence.com/static/"
    57 STATICFILES_ROOT = ''
     57STATIC_ROOT = ''
    5858
    59 # URL that handles the static files served from STATICFILES_ROOT.
     59# URL that handles the static files served from STATIC_ROOT.
    6060# Example: "http://static.lawrence.com/", "http://example.com/static/"
    61 STATICFILES_URL = '/static/'
     61STATIC_URL = '/static/'
    6262
    6363# URL prefix for admin media -- CSS, JavaScript and images.
    6464# Make sure to use a trailing slash.

  • django/contrib/staticfiles/context_processors.py 

    diff --git a/django/contrib/staticfiles/context_processors.py b/django/contrib/staticfiles/context_processors.py
index 3ed0071..dafd3c2 100644
    a b from django.conf import settings  
    22
    33def staticfiles(request):
    44    return {
    5         'STATICFILES_URL': settings.STATICFILES_URL,
     5        'STATIC_URL': settings.STATIC_URL,
    66    }

  • django/contrib/staticfiles/handlers.py 

    diff --git a/django/contrib/staticfiles/handlers.py b/django/contrib/staticfiles/handlers.py
index 20b0496..a7ac1a2 100644
    a b from django.contrib.staticfiles.views import serve  
    1010class StaticFilesHandler(WSGIHandler):
    1111    """
    1212    WSGI middleware that intercepts calls to the static files directory, as
    13     defined by the STATICFILES_URL setting, and serves those files.
     13    defined by the STATIC_URL setting, and serves those files.
    1414    """
    1515    def __init__(self, application, media_dir=None):
    1616        self.application = application
    … … class StaticFilesHandler(WSGIHandler):  
    2424        super(StaticFilesHandler, self).__init__()
    2525
    2626    def get_media_dir(self):
    27         return settings.STATICFILES_ROOT
     27        return settings.STATIC_ROOT
    2828
    2929    def get_media_url(self):
    30         return settings.STATICFILES_URL
     30        return settings.STATIC_URL
    3131
    3232    def _should_handle(self, path):
    3333        """

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

    diff --git a/django/contrib/staticfiles/management/commands/collectstatic.py b/django/contrib/staticfiles/management/commands/collectstatic.py
index d121223..8882ae2 100644
    a b from django.contrib.staticfiles import finders  
    1212class Command(NoArgsCommand):
    1313    """
    1414    Command that allows to copy or symlink media files from different
    15     locations to the settings.STATICFILES_ROOT.
     15    locations to the settings.STATIC_ROOT.
    1616    """
    1717    option_list = NoArgsCommand.option_list + (
    1818        make_option('--noinput', action='store_false', dest='interactive',
    … … Type 'yes' to continue, or 'no' to cancel: """)  
    8585            self.stdout.write("\n%s static file%s %s to '%s'%s.\n"
    8686                              % (actual_count, actual_count != 1 and 's' or '',
    8787                                 symlink and 'symlinked' or 'copied',
    88                                  settings.STATICFILES_ROOT,
     88                                 settings.STATIC_ROOT,
    8989                                 unmodified_count and ' (%s unmodified)'
    9090                                 % unmodified_count or ''))
    9191

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

    diff --git a/django/contrib/staticfiles/management/commands/runserver.py b/django/contrib/staticfiles/management/commands/runserver.py
index e138759..f4c2259 100644
    a b from django.contrib.staticfiles.handlers import StaticFilesHandler  
    88class Command(BaseRunserverCommand):
    99    option_list = BaseRunserverCommand.option_list + (
    1010        make_option('--nostatic', action="store_false", dest='use_static_handler', default=True,
    11             help='Tells Django to NOT automatically serve static files at STATICFILES_URL.'),
     11            help='Tells Django to NOT automatically serve static files at STATIC_URL.'),
    1212        make_option('--insecure', action="store_true", dest='insecure_serving', default=False,
    1313            help='Allows serving static files even if DEBUG is False.'),
    1414    )

  • django/contrib/staticfiles/storage.py 

    diff --git a/django/contrib/staticfiles/storage.py b/django/contrib/staticfiles/storage.py
index b4bfea7..db55895 100644
    a b class StaticFilesStorage(FileSystemStorage):  
    1212    Standard file system storage for site media files.
    1313   
    1414    The defaults for ``location`` and ``base_url`` are
    15     ``STATICFILES_ROOT`` and ``STATICFILES_URL``.
     15    ``STATIC_ROOT`` and ``STATIC_URL``.
    1616    """
    1717    def __init__(self, location=None, base_url=None, *args, **kwargs):
    1818        if location is None:
    19             location = settings.STATICFILES_ROOT
     19            location = settings.STATIC_ROOT
    2020        if base_url is None:
    21             base_url = settings.STATICFILES_URL
     21            base_url = settings.STATIC_URL
    2222        if not location:
    2323            raise ImproperlyConfigured("You're using the staticfiles app "
    24                 "without having set the STATICFILES_ROOT setting. Set it to "
     24                "without having set the STATIC_ROOT setting. Set it to "
    2525                "the absolute path of the directory that holds static media.")
    2626        if not base_url:
    2727            raise ImproperlyConfigured("You're using the staticfiles app "
    28                 "without having set the STATICFILES_URL setting. Set it to "
    29                 "URL that handles the files served from STATICFILES_ROOT.")
     28                "without having set the STATIC_URL setting. Set it to "
     29                "URL that handles the files served from STATIC_ROOT.")
    3030        if settings.DEBUG:
    3131            utils.check_settings()
    3232        super(StaticFilesStorage, self).__init__(location, base_url, *args, **kwargs)

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

    diff --git a/django/contrib/staticfiles/templatetags/staticfiles.py b/django/contrib/staticfiles/templatetags/staticfiles.py
deleted file mode 100644
index 6153f5a..0000000
    + -  
    1 from django import template
    2 from django.utils.encoding import iri_to_uri
    3 
    4 register = template.Library()
    5 
    6 class StaticFilesPrefixNode(template.Node):
    7 
    8     def __init__(self, varname=None):
    9         self.varname = varname
    10 
    11     def render(self, context):
    12         try:
    13             from django.conf import settings
    14         except ImportError:
    15             prefix = ''
    16         else:
    17             prefix = iri_to_uri(settings.STATICFILES_URL)
    18         if self.varname is None:
    19             return prefix
    20         context[self.varname] = prefix
    21         return ''
    22 
    23 @register.tag
    24 def get_staticfiles_prefix(parser, token):
    25     """
    26     Populates a template variable with the prefix (settings.STATICFILES_URL).
    27 
    28     Usage::
    29 
    30         {% get_staticfiles_prefix [as varname] %}
    31 
    32     Examples::
    33 
    34         {% get_staticfiles_prefix %}
    35         {% get_staticfiles_prefix as staticfiles_prefix %}
    36 
    37     """
    38     tokens = token.contents.split()
    39     if len(tokens) > 1 and tokens[1] != 'as':
    40         raise template.TemplateSyntaxError(
    41             "First argument in '%s' must be 'as'" % tokens[0])
    42     return StaticFilesPrefixNode(varname=(len(tokens) > 1 and tokens[2] or None))
    43 

  • django/contrib/staticfiles/urls.py 

    diff --git a/django/contrib/staticfiles/urls.py b/django/contrib/staticfiles/urls.py
index 70f04f2..952491b 100644
    a b if settings.DEBUG:  
    1111        url(r'^(?P<path>.*)$', 'django.contrib.staticfiles.views.serve'),
    1212    )
    1313
    14 def staticfiles_urlpatterns(prefix=None):
     14def static_urlpatterns(prefix=None):
    1515    """
    1616    Helper function to return a URL pattern for serving static files.
    1717    """
    1818    if not settings.DEBUG:
    1919        return []
    2020    if prefix is None:
    21         prefix = settings.STATICFILES_URL
     21        prefix = settings.STATIC_URL
    2222    if not prefix:
    2323        raise ImproperlyConfigured(
    24             "The prefix for the 'staticfiles_urlpatterns' helper is empty. "
    25             "Make sure the STATICFILES_URL setting is set correctly.")
     24            "The prefix for the 'static_urlpatterns' helper is empty. "
     25            "Make sure the STATIC_URL setting is set correctly.")
    2626    if '://' in prefix:
    2727        raise ImproperlyConfigured(
    28             "The STATICFILES_URL setting is a full URL, not a path and "
    29             "can't be used with the 'staticfiles_urlpatterns' helper.")
     28            "The STATIC_URL setting is a full URL, not a path and "
     29            "can't be used with the 'static_urlpatterns' helper.")
    3030    if prefix.startswith("/"):
    3131        prefix = prefix[1:]
    3232    return patterns('',

  • django/contrib/staticfiles/utils.py 

    diff --git a/django/contrib/staticfiles/utils.py b/django/contrib/staticfiles/utils.py
index 0071dbd..4efcb47 100644
    a b def check_settings():  
    3636    Checks if the MEDIA_(ROOT|URL) and STATICFILES_(ROOT|URL)
    3737    settings have the same value.
    3838    """
    39     if settings.MEDIA_URL == settings.STATICFILES_URL:
    40         raise ImproperlyConfigured("The MEDIA_URL and STATICFILES_URL "
     39    if settings.MEDIA_URL == settings.STATIC_URL:
     40        raise ImproperlyConfigured("The MEDIA_URL and STATIC_URL "
    4141                                   "settings must have individual values")
    42     if ((settings.MEDIA_ROOT and settings.STATICFILES_ROOT) and
    43             (settings.MEDIA_ROOT == settings.STATICFILES_ROOT)):
    44         raise ImproperlyConfigured("The MEDIA_ROOT and STATICFILES_ROOT "
     42    if ((settings.MEDIA_ROOT and settings.STATIC_ROOT) and
     43            (settings.MEDIA_ROOT == settings.STATIC_ROOT)):
     44        raise ImproperlyConfigured("The MEDIA_ROOT and STATIC_ROOT "
    4545                                   "settings must have individual values")

  • django/forms/widgets.py 

    diff --git a/django/forms/widgets.py b/django/forms/widgets.py
index cb12586..2b98638 100644
    a b  
    11"""
    22HTML Widget classes
    33"""
     4import datetime
     5from itertools import chain
     6import time
     7from urlparse import urljoin
     8from util import flatatt
    49
    510import django.utils.copycompat as copy
    6 from itertools import chain
    711from django.conf import settings
    812from django.utils.datastructures import MultiValueDict, MergeDict
    913from django.utils.html import escape, conditional_escape
    … … from django.utils.translation import ugettext, ugettext_lazy  
    1115from django.utils.encoding import StrAndUnicode, force_unicode
    1216from django.utils.safestring import mark_safe
    1317from django.utils import datetime_safe, formats
    14 import time
    15 import datetime
    16 from util import flatatt
    17 from urlparse import urljoin
    1818
    1919__all__ = (
    2020    'Media', 'MediaDefiningClass', 'Widget', 'TextInput', 'PasswordInput',
    … … class Media(StrAndUnicode):  
    6363                    for path in self._css[medium]]
    6464                for medium in media])
    6565
    66     def absolute_path(self, path):
     66    def absolute_path(self, path, prefix=None):
    6767        if path.startswith(u'http://') or path.startswith(u'https://') or path.startswith(u'/'):
    6868            return path
    69         return urljoin(settings.MEDIA_URL,path)
     69        if prefix is None and settings.STATIC_URL is not None:
     70            prefix = settings.STATIC_URL
     71        else:
     72            prefix = settings.MEDIA_URL # backwards compatibility
     73        return urljoin(prefix, path)
    7074
    7175    def __getitem__(self, name):
    7276        "Returns a Media object that only contains media of the given type"

  • docs/howto/static-files.txt 

    diff --git a/docs/howto/static-files.txt b/docs/howto/static-files.txt
index 37f1fc3..51ec2d2 100644
    a b Here's the basic usage in a nutshell:  
    5050       First, you'll need to make sure that ``django.contrib.staticfiles`` is in
    5151       your :setting:`INSTALLED_APPS`.
    5252
    53        Next, you'll need to edit :setting:`STATICFILES_ROOT` to point to where
     53       Next, you'll need to edit :setting:`STATIC_ROOT` to point to where
    5454       you'd like your static media stored. For example::
    5555
    56             STATICFILES_ROOT = "/home/jacob/projects/mysite.com/static_media"
     56            STATIC_ROOT = "/home/jacob/projects/mysite.com/static_media"
    5757
    58        You may also want to set the :setting:`STATICFILES_URL` setting at this
     58       You may also want to set the :setting:`STATIC_URL` setting at this
    5959       time, though the default value (of ``/static/``) is perfect for local
    6060       development.
    6161
    … … Here's the basic usage in a nutshell:  
    6969            ./manage.py collectstatic
    7070
    7171       This'll churn through your static file storage and move them into the
    72        directory given by :setting:`STATICFILES_ROOT`. (This is not necessary
     72       directory given by :setting:`STATIC_ROOT`. (This is not necessary
    7373       in local development if you are using :djadmin:`runserver` or adding
    74        ``staticfiles_urlpatterns`` to your URLconf; see below).
     74       ``static_urlpatterns`` to your URLconf; see below).
    7575
    7676    4. Deploy that media.
    7777
    7878       If you're using the built-in development server (the
    7979       :djadmin:`runserver` management command) and have the :setting:`DEBUG`
    8080       setting set to ``True``, your staticfiles will automatically be served
    81        from :setting:`STATICFILES_URL` in development.
     81       from :setting:`STATIC_URL` in development.
    8282
    8383       If you are using some other server for local development, you can
    8484       quickly serve static media locally by adding::
    8585
    86             from django.contrib.staticfiles.urls import staticfiles_urlpatterns
    87             urlpatterns += staticfiles_urlpatterns()
     86            from django.contrib.staticfiles.urls import static_urlpatterns
     87            urlpatterns += static_urlpatterns()
    8888
    8989       to the bottom of your URLconf. See :ref:`staticfiles-development` for
    9090       details.
    … … Here's the basic usage in a nutshell:  
    9898
    9999          .. code-block:: html+django
    100100
    101                <img src="{{ STATICFILES_URL }}images/hi.jpg />
     101               <img src="{{ STATIC_URL }}images/hi.jpg />
    102102
    103103       See :ref:`staticfiles-in-templates` for more details, including an
    104104       alternate method (using a template tag).
    … … the framework see :doc:`the staticfiles reference </ref/contrib/staticfiles>`.  
    115115   app is to make it easier to keep static files separate from user-uploaded
    116116   files. For this reason, you will probably want to make your
    117117   :setting:`MEDIA_ROOT` and :setting:`MEDIA_URL` different from your
    118    :setting:`STATICFILES_ROOT` and :setting:`STATICFILES_URL`. You will need to
     118   :setting:`STATIC_ROOT` and :setting:`STATIC_URL`. You will need to
    119119   arrange for serving of files in :setting:`MEDIA_ROOT` yourself;
    120120   ``staticfiles`` does not deal with user-uploaded media at all.
    121121
    … … development, and it makes it *very* hard to change where you've deployed your  
    136136media. If, for example, you wanted to switch to using a content delivery network
    137137(CDN), then you'd need to change more or less every single template.
    138138
    139 A far better way is to use the value of the :setting:`STATICFILES_URL` setting
     139A far better way is to use the value of the :setting:`STATIC_URL` setting
    140140directly in your templates. This means that a switch of media servers only
    141141requires changing that single value. Much better!
    142142
    … … editing that setting by hand it should look something like::  
    160160        'django.contrib.staticfiles.context_processors.staticfiles',
    161161    )
    162162
    163 Once that's done, you can refer to :setting:`STATICFILES_URL` in your templates:
     163Once that's done, you can refer to :setting:`STATIC_URL` in your templates:
    164164
    165165.. code-block:: html+django
    166166
    167      <img src="{{ STATICFILES_URL }}images/hi.jpg />
     167     <img src="{{ STATIC_URL }}images/hi.jpg />
    168168
    169 If ``{{ STATICFILES_URL }}`` isn't working in your template, you're probably not
     169If ``{{ STATIC_URL }}`` isn't working in your template, you're probably not
    170170using :class:`~django.template.RequestContext` when rendering the template.
    171171
    172172As a brief refresher, context processors add variables into the contexts of
    … … To see how that works, and to read more details, check out  
    180180With a template tag
    181181-------------------
    182182
    183 The second option is the :ttag:`get_staticfiles_prefix` template tag. You can
     183The second option is the :ttag:`get_static_prefix` template tag. You can
    184184use this if you're not using :class:`~django.template.RequestContext`, or if you
    185 need more control over exactly where and how :setting:`STATICFILES_URL` is
     185need more control over exactly where and how :setting:`STATIC_URL` is
    186186injected into the template. Here's an example:
    187187
    188188.. code-block:: html+django
    189189
    190190    {% load staticfiles %}
    191     <img src="{% get_staticfiles_prefix %}images/hi.jpg" />
     191    <img src="{% get_static_prefix %}images/hi.jpg" />
    192192
    193193There's also a second form you can use to avoid extra processing if you need the
    194194value multiple times:
    … … value multiple times:  
    196196.. code-block:: html+django
    197197
    198198    {% load staticfiles %}
    199     {% get_staticfiles_prefix as STATIC_PREFIX %}
     199    {% get_static_prefix as STATIC_PREFIX %}
    200200
    201201    <img src="{{ STATIC_PREFIX }}images/hi.jpg" />
    202202    <img src="{{ STATIC_PREFIX }}images/hi2.jpg" />
    … … Thus, the ``staticfiles`` app ships with a quick and dirty helper view that you  
    213213can use to serve files locally in development.
    214214
    215215This view is automatically enabled and will serve your static files at
    216 :setting:`STATICFILES_URL` when you use the built-in :djadmin:`runserver`.
     216:setting:`STATIC_URL` when you use the built-in :djadmin:`runserver`.
    217217
    218218To enable this view if you are using some other server for local development,
    219219you'll add a couple of lines to your URLconf. The first line goes at the top of
    220220the file, and the last line at the bottom::
    221221
    222     from django.contrib.staticfiles.urls import staticfiles_urlpatterns
     222    from django.contrib.staticfiles.urls import static_urlpatterns
    223223
    224224    # ... the rest of your URLconf goes here ...
    225225
    226     urlpatterns += staticfiles_urlpatterns()
     226    urlpatterns += static_urlpatterns()
    227227
    228 This will inspect your :setting:`STATICFILES_URL` and
    229 :setting:`STATICFILES_ROOT` settings and wire up the view to serve static media
     228This will inspect your :setting:`STATIC_URL` and
     229:setting:`STATIC_ROOT` settings and wire up the view to serve static media
    230230accordingly. Don't forget to set the :setting:`STATICFILES_DIRS` setting
    231231appropriately to let ``django.contrib.staticfiles`` know where to look for
    232232files.
    … … Serving static files in production  
    249249
    250250The basic outline of putting static files into production is simple: run the
    251251:djadmin:`collectstatic` command when static media changes, then arrange for the
    252 collected media directory (:setting:`STATICFILES_ROOT`) to be moved to the media
     252collected media directory (:setting:`STATIC_ROOT`) to be moved to the media
    253253server and served.
    254254
    255255Of course, as with all deployment tasks, the devil's in the details. Every
    … … app, the basic outline gets modified to look something like:  
    264264
    265265    * Push your code up to the deployment server.
    266266    * On the server, run :djadmin:`collectstatic` to move all the media into
    267       :setting:`STATICFILES_ROOT`.
    268     * Point your web server at :setting:`STATICFILES_ROOT`. For example, here's
     267      :setting:`STATIC_ROOT`.
     268    * Point your web server at :setting:`STATIC_ROOT`. For example, here's
    269269      :ref:`how to do this under Apache and mod_wsgi <serving-media-files>`.
    270270
    271271You'll probably want to automate this process, especially if you've got multiple
    … … Since your media server won't be running Django, you'll need to modify the  
    322322deployment strategy to look something like:
    323323
    324324    * When your media changes, run :djadmin:`collectstatic` locally.
    325     * Push your local :setting:`STATICFILES_ROOT` up to the media server
     325    * Push your local :setting:`STATIC_ROOT` up to the media server
    326326      into the directory that's being served. ``rsync`` is a good
    327327      choice for this step since it only needs to transfer the
    328328      bits of static media that have changed.
    … … you'll need to make a few changes:  
    403403    * The management commands ``build_static`` and ``resolve_static`` are now
    404404      called :djadmin:`collectstatic` and :djadmin:`findstatic`.
    405405
    406     * The settings ``STATIC_URL`` and ``STATIC_ROOT`` were renamed to
    407       :setting:`STATICFILES_URL` and :setting:`STATICFILES_ROOT`.
    408 
    409406    * The settings ``STATICFILES_PREPEND_LABEL_APPS``,
    410407      ``STATICFILES_MEDIA_DIRNAMES`` and ``STATICFILES_EXCLUDED_APPS`` were
    411408      removed.

  • docs/man/django-admin.1 

    diff --git a/docs/man/django-admin.1 b/docs/man/django-admin.1
index 2197af6..f9b530a 100644
    a b Do not prompt the user for input.  
    165165Disable the development server's auto\-reloader.
    166166.TP
    167167.I \-\-nostatic
    168 Disable automatic serving of static files from STATICFILES_URL.
     168Disable automatic serving of static files from STATIC_URL.
    169169.TP
    170170.I \-\-insecure
    171171Enables serving of static files even if DEBUG is False.

  • docs/ref/contrib/staticfiles.txt 

    diff --git a/docs/ref/contrib/staticfiles.txt b/docs/ref/contrib/staticfiles.txt
index f82fd79..4fe38d2 100644
    a b Settings  
    2424.. highlight:: python
    2525
    2626The following settings control the behavior of the staticfiles app. Only
    27 :setting:`STATICFILES_ROOT` is required, but you'll probably also need to
    28 configure :setting:`STATICFILES_URL` as well.
     27:setting:`STATIC_ROOT` is required, but you'll probably also need to
     28configure :setting:`STATIC_URL` as well.
    2929
    30 .. setting:: STATICFILES_ROOT
     30.. setting:: STATIC_ROOT
    3131
    32 STATICFILES_ROOT
    33 ----------------
     32STATIC_ROOT
     33-----------
    3434
    3535Default: ``''`` (Empty string)
    3636
    3737The absolute path to the directory that the :djadmin:`collectstatic` management
    3838command will collect static files into, for serving from
    39 :setting:`STATICFILES_URL`::
     39:setting:`STATIC_URL`::
    4040
    41    STATICFILES_ROOT = "/home/example.com/static/"
     41   STATIC_ROOT = "/home/example.com/static/"
    4242
    4343This is a **required setting** unless you've overridden
    4444:setting:`STATICFILES_STORAGE` and are using a custom storage backend.
    … … This is not a place to store your static files permanently under version  
    4747control; you should do that in directories that will be found by your
    4848:setting:`STATICFILES_FINDERS` (by default, per-app ``static/`` subdirectories,
    4949and any directories you include in :setting:`STATICFILES_DIRS`). Files from
    50 those locations will be collected into :setting:`STATICFILES_ROOT`.
     50those locations will be collected into :setting:`STATIC_ROOT`.
    5151
    52 .. setting:: STATICFILES_URL
     52.. setting:: STATIC_URL
    5353
    54 STATICFILES_URL
     54STATIC_URL
    5555---------------
    5656
    5757Default: ``'/static/'``
    5858
    59 The URL that handles the files served from :setting:`STATICFILES_ROOT`, e.g.::
     59The URL that handles the files served from :setting:`STATIC_ROOT`, e.g.::
    6060
    61     STATICFILES_URL = '/site_media/static/'
     61    STATIC_URL = '/site_media/static/'
    6262
    6363... or perhaps::
    6464
    65     STATICFILES_URL = 'http://static.example.com/'
     65    STATIC_URL = 'http://static.example.com/'
    6666
    6767This should **always** have a trailing slash.
    6868
    … … tuples, e.g.::  
    9898
    9999With this configuration, the :djadmin:`collectstatic` management command would
    100100for example collect the stats files in a ``'downloads'`` directory. So
    101 assuming you have :setting:`STATICFILES_URL` set ``'/static/'``, this would
     101assuming you have :setting:`STATIC_URL` set ``'/static/'``, this would
    102102allow you to refer to the file ``'/opt/webfiles/stats/polls_20101022.tar.gz'``
    103103with ``'/static/downloads/polls_20101022.tar.gz'`` in your templates.
    104104
    … … collectstatic  
    160160
    161161.. django-admin:: collectstatic
    162162
    163 Collects the static files into :setting:`STATICFILES_ROOT`.
     163Collects the static files into :setting:`STATIC_ROOT`.
    164164
    165165Duplicate file names are by default resolved in a similar way to how template
    166166resolution works: the file that is first found in one of the specified
    … … collected for a given path.  
    223223Other Helpers
    224224=============
    225225
    226 The ``staticfiles`` context processor
    227 -------------------------------------
     226The ``static`` context processor
     227--------------------------------
    228228
    229 .. function:: django.contrib.staticfiles.context_processors.staticfiles
     229.. function:: django.contrib.staticfiles.context_processors.static
    230230
    231 This context processor adds the :setting:`STATICFILES_URL` into each template
    232 context as the variable ``{{ STATICFILES_URL }}``. To use it, make sure that
    233 ``'django.contrib.staticfiles.context_processors.staticfiles'`` appears
     231This context processor adds the :setting:`STATIC_URL` into each template
     232context as the variable ``{{ STATIC_URL }}``. To use it, make sure that
     233``'django.contrib.staticfiles.context_processors.static'`` appears
    234234somewhere in your :setting:`TEMPLATE_CONTEXT_PROCESSORS` setting.
    235235
    236236Remember, only templates rendered with :class:`~django.template.RequestContext`
    237237will have acces to the data provided by this (and any) context processor.
    238238
    239 .. templatetag:: get_staticfiles_prefix
     239.. templatetag:: get_static_prefix
    240240
    241 The ``get_staticfiles_prefix`` templatetag
    242 ==========================================
     241The ``get_static_prefix`` templatetag
     242=====================================
    243243
    244244.. highlight:: html+django
    245245
    246246If you're not using :class:`~django.template.RequestContext`, or if you need
    247 more control over exactly where and how :setting:`STATICFILES_URL` is injected
    248 into the template, you can use the :ttag:`get_staticfiles_prefix` template tag
     247more control over exactly where and how :setting:`STATIC_URL` is injected
     248into the template, you can use the :ttag:`get_static_prefix` template tag
    249249instead::
    250250
    251251    {% load staticfiles %}
    252     <img src="{% get_staticfiles_prefix %}images/hi.jpg" />
     252    <img src="{% get_static_prefix %}images/hi.jpg" />
    253253
    254254There's also a second form you can use to avoid extra processing if you need
    255255the value multiple times::
    256256
    257257    {% load staticfiles %}
    258     {% get_staticfiles_prefix as STATIC_PREFIX %}
     258    {% get_static_prefix as STATIC_PREFIX %}
    259259
    260260    <img src="{{ STATIC_PREFIX }}images/hi.jpg" />
    261261    <img src="{{ STATIC_PREFIX }}images/hi2.jpg" />
    … … primary URL configuration::  
    292292       )
    293293
    294294Note, the begin of the pattern (``r'^static/'``) should be your
    295 :setting:`STATICFILES_URL` setting.
     295:setting:`STATIC_URL` setting.
    296296
    297297Since this is a bit finicky, there's also a helper function that'll do this for you:
    298298
    299 .. function:: django.contrib.staticfiles.urls.staticfiles_urlpatterns()
     299.. function:: django.contrib.staticfiles.urls.static_urlpatterns()
    300300
    301301This will return the proper URL pattern for serving static files to your
    302302already defined pattern list. Use it like this::
    303303
    304    from django.contrib.staticfiles.urls import staticfiles_urlpatterns
     304   from django.contrib.staticfiles.urls import static_urlpatterns
    305305
    306306   # ... the rest of your URLconf here ...
    307307
    308    urlpatterns += staticfiles_urlpatterns()
     308   urlpatterns += static_urlpatterns()
    309309

  • docs/ref/settings.txt 

    diff --git a/docs/ref/settings.txt b/docs/ref/settings.txt
index b394cd7..856e619 100644
    a b administrative interface. Make sure to use a trailing slash, and to have this be  
    5656different from the :setting:``MEDIA_URL`` setting (since the same URL cannot be
    5757mapped onto two different sets of files). For integration with :doc:`staticfiles
    5858</ref/contrib/staticfiles>`, this should be the same as
    59 :setting:`STATICFILES_URL` followed by ``'admin/'``.
     59:setting:`STATIC_URL` followed by ``'admin/'``.
    6060
    6161.. setting:: ADMINS
    6262

  • docs/releases/1.3.txt 

    diff --git a/docs/releases/1.3.txt b/docs/releases/1.3.txt
index b5c0035..f795e77 100644
    a b In previous versions of Django, it was common to place static assets in  
    5959app is to make it easier to keep static files separate from user-uploaded
    6060files. For this reason, you will probably want to make your
    6161:setting:`MEDIA_ROOT` and :setting:`MEDIA_URL` different from your
    62 :setting:`STATICFILES_ROOT` and :setting:`STATICFILES_URL`. You will need to
     62:setting:`STATIC_ROOT` and :setting:`STATIC_URL`. You will need to
    6363arrange for serving of files in :setting:`MEDIA_ROOT` yourself;
    6464``staticfiles`` does not deal with user-uploaded media at all.
    6565

  • tests/regressiontests/staticfiles_tests/tests.py 

    diff --git a/tests/regressiontests/staticfiles_tests/tests.py b/tests/regressiontests/staticfiles_tests/tests.py
index 0a6c060..2d16983 100644
    a b class StaticFilesTestCase(TestCase):  
    2323    Test case with a couple utility assertions.
    2424    """
    2525    def setUp(self):
    26         self.old_staticfiles_url = settings.STATICFILES_URL
    27         self.old_staticfiles_root = settings.STATICFILES_ROOT
     26        self.old_static_url = settings.STATIC_URL
     27        self.old_static_root = settings.STATIC_ROOT
    2828        self.old_staticfiles_dirs = settings.STATICFILES_DIRS
    2929        self.old_staticfiles_finders = settings.STATICFILES_FINDERS
    3030        self.old_media_root = settings.MEDIA_ROOT
    … … class StaticFilesTestCase(TestCase):  
    4040        settings.DEBUG = True
    4141        settings.MEDIA_ROOT =  os.path.join(site_media, 'media')
    4242        settings.MEDIA_URL = '/media/'
    43         settings.STATICFILES_ROOT = os.path.join(site_media, 'static')
    44         settings.STATICFILES_URL = '/static/'
     43        settings.STATIC_ROOT = os.path.join(site_media, 'static')
     44        settings.STATIC_URL = '/static/'
    4545        settings.ADMIN_MEDIA_PREFIX = '/static/admin/'
    4646        settings.STATICFILES_DIRS = (
    4747            os.path.join(TEST_ROOT, 'project', 'documents'),
    … … class StaticFilesTestCase(TestCase):  
    5252            'django.contrib.staticfiles.finders.DefaultStorageFinder',
    5353        )
    5454        settings.INSTALLED_APPS = [
     55            "django.contrib.staticfiles",
    5556            "regressiontests.staticfiles_tests",
    5657        ]
    5758
    … … class StaticFilesTestCase(TestCase):  
    6566        settings.MEDIA_ROOT = self.old_media_root
    6667        settings.MEDIA_URL = self.old_media_url
    6768        settings.ADMIN_MEDIA_PREFIX = self.old_admin_media_prefix
    68         settings.STATICFILES_ROOT = self.old_staticfiles_root
    69         settings.STATICFILES_URL = self.old_staticfiles_url
     69        settings.STATIC_ROOT = self.old_static_root
     70        settings.STATIC_URL = self.old_static_url
    7071        settings.STATICFILES_DIRS = self.old_staticfiles_dirs
    7172        settings.STATICFILES_FINDERS = self.old_staticfiles_finders
    7273        settings.INSTALLED_APPS = self.old_installed_apps
    … … class BuildStaticTestCase(StaticFilesTestCase):  
    9192    def setUp(self):
    9293        super(BuildStaticTestCase, self).setUp()
    9394        self.old_staticfiles_storage = settings.STATICFILES_STORAGE
    94         self.old_root = settings.STATICFILES_ROOT
    95         settings.STATICFILES_ROOT = tempfile.mkdtemp()
     95        self.old_root = settings.STATIC_ROOT
     96        settings.STATIC_ROOT = tempfile.mkdtemp()
    9697        self.run_collectstatic()
    9798
    9899    def tearDown(self):
    99         shutil.rmtree(settings.STATICFILES_ROOT)
    100         settings.STATICFILES_ROOT = self.old_root
     100        shutil.rmtree(settings.STATIC_ROOT)
     101        settings.STATIC_ROOT = self.old_root
    101102        super(BuildStaticTestCase, self).tearDown()
    102103
    103104    def run_collectstatic(self, **kwargs):
    … … class BuildStaticTestCase(StaticFilesTestCase):  
    106107
    107108    def _get_file(self, filepath):
    108109        assert filepath, 'filepath is empty.'
    109         filepath = os.path.join(settings.STATICFILES_ROOT, filepath)
     110        filepath = os.path.join(settings.STATIC_ROOT, filepath)
    110111        f = open(filepath)
    111112        try:
    112113            return f.read()
    … … class TestBuildStaticDryRun(BuildStaticTestCase):  
    231232        """
    232233        With --dry-run, no files created in destination dir.
    233234        """
    234         self.assertEquals(os.listdir(settings.STATICFILES_ROOT), [])
     235        self.assertEquals(os.listdir(settings.STATIC_ROOT), [])
    235236
    236237
    237238if sys.platform != 'win32':
    … … if sys.platform != 'win32':  
    251252            With ``--link``, symbolic links are created.
    252253
    253254            """
    254             self.failUnless(os.path.islink(os.path.join(settings.STATICFILES_ROOT, 'test.txt')))
     255            self.failUnless(os.path.islink(os.path.join(settings.STATIC_ROOT, 'test.txt')))
    255256
    256257
    257258class TestServeStatic(StaticFilesTestCase):
    … … class TestServeStatic(StaticFilesTestCase):  
    262263
    263264    def _response(self, filepath):
    264265        return self.client.get(
    265             posixpath.join(settings.STATICFILES_URL, filepath))
     266            posixpath.join(settings.STATIC_URL, filepath))
    266267
    267268    def assertFileContains(self, filepath, text):
    268269        self.assertContains(self._response(filepath), text)
    … … class TestServeDisabled(TestServeStatic):  
    287288
    288289class TestServeStaticWithDefaultURL(TestServeStatic, TestDefaults):
    289290    """
    290     Test static asset serving view with staticfiles_urlpatterns helper.
     291    Test static asset serving view with static_urlpatterns helper.
    291292    """
    292293    pass
    293294
    294295class TestServeStaticWithURLHelper(TestServeStatic, TestDefaults):
    295296    """
    296     Test static asset serving view with staticfiles_urlpatterns helper.
     297    Test static asset serving view with static_urlpatterns helper.
    297298    """
    298299    urls = "regressiontests.staticfiles_tests.urls.helper"
    299300
    … … class TestMiscFinder(TestCase):  
    374375            finders.get_finder, "foo.bar.FooBarFinder")
    375376
    376377
    377 class TemplateTagTest(TestCase):
    378     def test_get_staticfiles_prefix(self):
     378class TemplateTagTest(StaticFilesTestCase):
     379    def test_get_static_prefix(self):
    379380        """
    380         Test the get_staticfiles_prefix helper return the STATICFILES_URL setting.
     381        Test the get_static_prefix helper return the STATIC_URL setting.
    381382        """
    382383        self.assertEquals(Template(
    383             "{% load staticfiles %}"
    384             "{% get_staticfiles_prefix %}"
    385         ).render(Context()), settings.STATICFILES_URL)
     384            "{% load static %}"
     385            "{% get_static_prefix %}"
     386        ).render(Context()), settings.STATIC_URL)
    386387
    387     def test_get_staticfiles_prefix_with_as(self):
     388    def test_get_static_prefix_with_as(self):
    388389        """
    389         Test the get_staticfiles_prefix helper return the STATICFILES_URL setting.
     390        Test the get_static_prefix helper return the STATIC_URL setting.
    390391        """
    391392        self.assertEquals(Template(
    392             "{% load staticfiles %}"
    393             "{% get_staticfiles_prefix as staticfiles_prefix %}"
    394             "{{ staticfiles_prefix }}"
    395         ).render(Context()), settings.STATICFILES_URL)
     393            "{% load static %}"
     394            "{% get_static_prefix as static_prefix %}"
     395            "{{ static_prefix }}"
     396        ).render(Context()), settings.STATIC_URL)

  • tests/regressiontests/staticfiles_tests/urls/helper.py 

    diff --git a/tests/regressiontests/staticfiles_tests/urls/helper.py b/tests/regressiontests/staticfiles_tests/urls/helper.py
index e4951d1..51ab63e 100644
    a b  
    1 from django.contrib.staticfiles.urls import staticfiles_urlpatterns
     1from django.contrib.staticfiles.urls import static_urlpatterns
    22
    3 urlpatterns = staticfiles_urlpatterns()
     3urlpatterns = static_urlpatterns()
Back to Top