Ticket #14693: 14693.1.diff

File 14693.1.diff, 36.1 KB (added by Jannis Leidel, 14 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