Ticket #14693: 14693.2.2.diff

File 14693.2.2.diff, 49.2 KB (added by jezdez, 5 years ago)

Moved context processors and template tags to core since those settings are core settings.

  • django/conf/global_settings.py

    diff --git a/django/conf/global_settings.py b/django/conf/global_settings.py
    index fab2d0f..79be86c 100644
    a b TEMPLATE_CONTEXT_PROCESSORS = ( 
    195195    'django.core.context_processors.debug',
    196196    'django.core.context_processors.i18n',
    197197    'django.core.context_processors.media',
     198    'django.core.context_processors.static',
    198199#    'django.core.context_processors.request',
    199200    'django.contrib.messages.context_processors.messages',
    200     'django.contrib.staticfiles.context_processors.staticfiles',
    201201)
    202202
    203203# Output to use in template system for invalid (e.g. misspelled) variables.
    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/admin/templatetags/adminmedia.py

    diff --git a/django/contrib/admin/templatetags/adminmedia.py b/django/contrib/admin/templatetags/adminmedia.py
    index 5429810..0671efc 100644
    a b  
    11from django.template import Library
    2 from django.utils.encoding import iri_to_uri
     2from django.templatetags.static import PrefixNode
    33
    44register = Library()
    55
     6@register.simple_tag
    67def admin_media_prefix():
    78    """
    89    Returns the string contained in the setting ADMIN_MEDIA_PREFIX.
    910    """
    10     try:
    11         from django.conf import settings
    12     except ImportError:
    13         return ''
    14     return iri_to_uri(settings.ADMIN_MEDIA_PREFIX)
    15 admin_media_prefix = register.simple_tag(admin_media_prefix)
     11    return PrefixNode.get_prefix("ADMIN_MEDIA_PREFIX")
  • deleted file django/contrib/staticfiles/context_processors.py

    diff --git a/django/contrib/staticfiles/context_processors.py b/django/contrib/staticfiles/context_processors.py
    deleted file mode 100644
    index 3ed0071..0000000
    + -  
    1 from django.conf import settings
    2 
    3 def staticfiles(request):
    4     return {
    5         'STATICFILES_URL': settings.STATICFILES_URL,
    6     }
  • django/contrib/staticfiles/handlers.py

    diff --git a/django/contrib/staticfiles/handlers.py b/django/contrib/staticfiles/handlers.py
    index 20b0496..54a52d3 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    """
    15     def __init__(self, application, media_dir=None):
     15    def __init__(self, application, base_dir=None):
    1616        self.application = application
    17         if media_dir:
    18             self.media_dir = media_dir
     17        if base_dir:
     18            self.base_dir = base_dir
    1919        else:
    20             self.media_dir = self.get_media_dir()
    21         self.media_url = urlparse(self.get_media_url())
     20            self.base_dir = self.get_base_dir()
     21        self.base_url = urlparse(self.get_base_url())
    2222        if settings.DEBUG:
    2323            utils.check_settings()
    2424        super(StaticFilesHandler, self).__init__()
    2525
    26     def get_media_dir(self):
    27         return settings.STATICFILES_ROOT
     26    def get_base_dir(self):
     27        return settings.STATIC_ROOT
    2828
    29     def get_media_url(self):
    30         return settings.STATICFILES_URL
     29    def get_base_url(self):
     30        return settings.STATIC_URL
    3131
    3232    def _should_handle(self, path):
    3333        """
    3434        Checks if the path should be handled. Ignores the path if:
    3535
    36         * the host is provided as part of the media_url
     36        * the host is provided as part of the base_url
    3737        * the request's path isn't under the media path (or equal)
    3838        * settings.DEBUG isn't True
    3939        """
    40         return (self.media_url[2] != path and
    41             path.startswith(self.media_url[2]) and not self.media_url[1])
     40        return (self.base_url[2] != path and
     41            path.startswith(self.base_url[2]) and not self.base_url[1])
    4242
    4343    def file_path(self, url):
    4444        """
    4545        Returns the relative path to the media file on disk for the given URL.
    4646
    47         The passed URL is assumed to begin with ``media_url``.  If the
     47        The passed URL is assumed to begin with ``base_url``.  If the
    4848        resultant file path is outside the media directory, then a ValueError
    4949        is raised.
    5050        """
    51         # Remove ``media_url``.
    52         relative_url = url[len(self.media_url[2]):]
     51        relative_url = url[len(self.base_url[2]):]
    5352        return urllib.url2pathname(relative_url)
    5453
    5554    def serve(self, request):
  • 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..eb0eabf 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.")
    26         if not base_url:
     26        # check for None since we might use a root URL (``/``)
     27        if base_url is None:
    2728            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.")
     29                "without having set the STATIC_URL setting. Set it to "
     30                "URL that handles the files served from STATIC_ROOT.")
    3031        if settings.DEBUG:
    3132            utils.check_settings()
    3233        super(StaticFilesStorage, self).__init__(location, base_url, *args, **kwargs)
  • deleted file django/contrib/staticfiles/templatetags/staticfiles.py

    diff --git a/django/contrib/staticfiles/templatetags/__init__.py b/django/contrib/staticfiles/templatetags/__init__.py
    deleted file mode 100644
    index e69de29..0000000
    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..aa4ab45 100644
    a b def staticfiles_urlpatterns(prefix=None): 
    1818    if not settings.DEBUG:
    1919        return []
    2020    if prefix is None:
    21         prefix = settings.STATICFILES_URL
    22     if not prefix:
     21        prefix = settings.STATIC_URL
     22    if not prefix or '://' in prefix:
    2323        raise ImproperlyConfigured(
    24             "The prefix for the 'staticfiles_urlpatterns' helper is empty. "
    25             "Make sure the STATICFILES_URL setting is set correctly.")
    26     if '://' in prefix:
    27         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.")
     24            "The prefix for the 'staticfiles_urlpatterns' helper is invalid.")
    3025    if prefix.startswith("/"):
    3126        prefix = prefix[1:]
    3227    return patterns('',
  • django/contrib/staticfiles/utils.py

    diff --git a/django/contrib/staticfiles/utils.py b/django/contrib/staticfiles/utils.py
    index 0071dbd..d307253 100644
    a b def get_files(storage, ignore_patterns=[], location=''): 
    3333
    3434def check_settings():
    3535    """
    36     Checks if the MEDIA_(ROOT|URL) and STATICFILES_(ROOT|URL)
     36    Checks if the MEDIA_(ROOT|URL) and STATIC_(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/core/context_processors.py

    diff --git a/django/core/context_processors.py b/django/core/context_processors.py
    index 7a59728..fa05d42 100644
    a b def i18n(request): 
    6666
    6767    return context_extras
    6868
     69def static(request):
     70    """
     71    Adds static-related context variables to the context.
     72
     73    """
     74    return {'STATIC_URL': settings.STATIC_URL}
     75
    6976def media(request):
    7077    """
    7178    Adds media-related context variables to the context.
  • django/core/servers/basehttp.py

    diff --git a/django/core/servers/basehttp.py b/django/core/servers/basehttp.py
    index 9c92a88..7667558 100644
    a b class AdminMediaHandler(StaticFilesHandler): 
    643643    security and is not super efficient.
    644644    """
    645645
    646     def get_media_dir(self):
     646    def get_base_dir(self):
    647647        import django
    648648        return os.path.join(django.__path__[0], 'contrib', 'admin', 'media')
    649649
    650     def get_media_url(self):
     650    def get_base_url(self):
    651651        from django.conf import settings
    652652        return settings.ADMIN_MEDIA_PREFIX
    653653
    class AdminMediaHandler(StaticFilesHandler): 
    660660        is raised.
    661661        """
    662662        # Remove ``media_url``.
    663         relative_url = url[len(self.media_url[2]):]
     663        relative_url = url[len(self.base_url[2]):]
    664664        relative_path = urllib.url2pathname(relative_url)
    665         return safe_join(self.media_dir, relative_path)
     665        return safe_join(self.base_dir, relative_path)
    666666
    667667    def serve(self, request):
    668668        document_root, path = os.path.split(self.file_path(request.path))
    class AdminMediaHandler(StaticFilesHandler): 
    673673        """
    674674        Checks if the path should be handled. Ignores the path if:
    675675
    676         * the host is provided as part of the media_url
    677         * the request's path isn't under the media path
     676        * the host is provided as part of the base_url
     677        * the request's path isn't under the base path
    678678        """
    679         return path.startswith(self.media_url[2]) and not self.media_url[1]
     679        return path.startswith(self.base_url[2]) and not self.base_url[1]
    680680
    681681
    682682def run(addr, port, wsgi_handler):
  • django/forms/widgets.py

    diff --git a/django/forms/widgets.py b/django/forms/widgets.py
    index cb12586..8eb5fef 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:
     70            if settings.STATIC_URL is None:
     71                 # backwards compatibility
     72                prefix = settings.MEDIA_URL
     73            else:
     74                prefix = settings.STATIC_URL
     75        return urljoin(prefix, path)
    7076
    7177    def __getitem__(self, name):
    7278        "Returns a Media object that only contains media of the given type"
  • new file django/templatetags/static.py

    diff --git a/django/templatetags/static.py b/django/templatetags/static.py
    new file mode 100644
    index 0000000..0213318
    - +  
     1from django import template
     2from django.utils.encoding import iri_to_uri
     3
     4register = template.Library()
     5
     6class PrefixNode(template.Node):
     7
     8    def __repr__(self):
     9        return "<PrefixNode for %r>" % self.name
     10
     11    def __init__(self, varname=None, name=None):
     12        if name is None:
     13            raise template.TemplateSyntaxError(
     14                "Prefix nodes must be given a name to return.")
     15        self.varname = varname
     16        self.name = name
     17
     18    @classmethod
     19    def handle_token(cls, parser, token, name):
     20        """
     21        Class method to parse prefix node and return a Node.
     22        """
     23        tokens = token.contents.split()
     24        if len(tokens) > 1 and tokens[1] != 'as':
     25            raise template.TemplateSyntaxError(
     26                "First argument in '%s' must be 'as'" % tokens[0])
     27        if len(tokens) > 1:
     28            varname = tokens[2]
     29        else:
     30            varname = None
     31        return cls(varname, name)
     32
     33    @classmethod
     34    def get_prefix(cls, name):
     35        try:
     36            from django.conf import settings
     37        except ImportError:
     38            prefix = ''
     39        else:
     40            prefix = iri_to_uri(getattr(settings, name, ''))
     41        return prefix
     42
     43    def render(self, context):
     44        prefix = self.get_prefix(self.name)
     45        if self.varname is None:
     46            return prefix
     47        context[self.varname] = prefix
     48        return ''
     49
     50@register.tag
     51def get_static_prefix(parser, token):
     52    """
     53    Populates a template variable with the static prefix,
     54    ``settings.STATIC_URL``.
     55
     56    Usage::
     57
     58        {% get_static_prefix [as varname] %}
     59
     60    Examples::
     61
     62        {% get_static_prefix %}
     63        {% get_static_prefix as static_prefix %}
     64
     65    """
     66    return PrefixNode.handle_token(parser, token, "STATIC_URL")
     67
     68@register.tag
     69def get_media_prefix(parser, token):
     70    """
     71    Populates a template variable with the static prefix,
     72    ``settings.MEDIA_URL``.
     73
     74    Usage::
     75
     76        {% get_media_prefix [as varname] %}
     77
     78    Examples::
     79
     80        {% get_media_prefix %}
     81        {% get_media_prefix as media_prefix %}
     82
     83    """
     84    return PrefixNode.handle_token(parser, token, "MEDIA_URL")
  • docs/howto/static-files.txt

    diff --git a/docs/howto/static-files.txt b/docs/howto/static-files.txt
    index 37f1fc3..e27cb99 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
    7474       ``staticfiles_urlpatterns`` to your URLconf; see below).
    7575
    Here's the basic usage in a nutshell: 
    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::
    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
    With a context processor 
    147147------------------------
    148148
    149149The included context processor is the easy way. Simply make sure
    150 ``'django.contrib.staticfiles.context_processors.staticfiles'`` is in your
     150``'django.core.context_processors.static'`` is in your
    151151:setting:`TEMPLATE_CONTEXT_PROCESSORS`. It's there by default, and if you're
    152152editing that setting by hand it should look something like::
    153153
    editing that setting by hand it should look something like:: 
    155155        'django.core.context_processors.debug',
    156156        'django.core.context_processors.i18n',
    157157        'django.core.context_processors.media',
     158        'django.core.context_processors.static',
    158159        'django.contrib.auth.context_processors.auth',
    159160        'django.contrib.messages.context_processors.messages',
    160         '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
    190     {% load staticfiles %}
    191     <img src="{% get_staticfiles_prefix %}images/hi.jpg" />
     190    {% load static %}
     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:
    195195
    196196.. code-block:: html+django
    197197
    198     {% load staticfiles %}
    199     {% get_staticfiles_prefix as STATIC_PREFIX %}
     198    {% load static %}
     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
    the file, and the last line at the bottom:: 
    225225
    226226    urlpatterns += staticfiles_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
    232 files.
     232(additional) files.
    233233
    234234.. warning::
    235235
    files. 
    239239    **insecure**. This is only intended for local development, and should
    240240    **never be used in production**.
    241241
     242    Additionally, your :setting:`STATIC_URL` setting can't be either empty
     243    or a full URL such as ``http://static.example.com/``.
     244
    242245For a few more details, including an alternate method of enabling this view,
    243246see :ref:`staticfiles-development-view`.
    244247
    Serving static files in production 
    249252
    250253The basic outline of putting static files into production is simple: run the
    251254:djadmin:`collectstatic` command when static media changes, then arrange for the
    252 collected media directory (:setting:`STATICFILES_ROOT`) to be moved to the media
     255collected media directory (:setting:`STATIC_ROOT`) to be moved to the media
    253256server and served.
    254257
    255258Of course, as with all deployment tasks, the devil's in the details. Every
    app, the basic outline gets modified to look something like: 
    264267
    265268    * Push your code up to the deployment server.
    266269    * 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
     270      :setting:`STATIC_ROOT`.
     271    * Point your web server at :setting:`STATIC_ROOT`. For example, here's
    269272      :ref:`how to do this under Apache and mod_wsgi <serving-media-files>`.
    270273
    271274You'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 
    322325deployment strategy to look something like:
    323326
    324327    * When your media changes, run :djadmin:`collectstatic` locally.
    325     * Push your local :setting:`STATICFILES_ROOT` up to the media server
     328    * Push your local :setting:`STATIC_ROOT` up to the media server
    326329      into the directory that's being served. ``rsync`` is a good
    327330      choice for this step since it only needs to transfer the
    328331      bits of static media that have changed.
    you'll need to make a few changes: 
    403406    * The management commands ``build_static`` and ``resolve_static`` are now
    404407      called :djadmin:`collectstatic` and :djadmin:`findstatic`.
    405408
    406     * The settings ``STATIC_URL`` and ``STATIC_ROOT`` were renamed to
    407       :setting:`STATICFILES_URL` and :setting:`STATICFILES_ROOT`.
    408 
    409409    * The settings ``STATICFILES_PREPEND_LABEL_APPS``,
    410410      ``STATICFILES_MEDIA_DIRNAMES`` and ``STATICFILES_EXCLUDED_APPS`` were
    411411      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..df31323 100644
    a b Settings 
    2323
    2424.. highlight:: python
    2525
    26 The 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.
    29 
    30 .. setting:: STATICFILES_ROOT
    31 
    32 STATICFILES_ROOT
    33 ----------------
    34 
    35 Default: ``''`` (Empty string)
    36 
    37 The absolute path to the directory that the :djadmin:`collectstatic` management
    38 command will collect static files into, for serving from
    39 :setting:`STATICFILES_URL`::
    40 
    41    STATICFILES_ROOT = "/home/example.com/static/"
    42 
    43 This is a **required setting** unless you've overridden
    44 :setting:`STATICFILES_STORAGE` and are using a custom storage backend.
    45 
    46 This is not a place to store your static files permanently under version
    47 control; you should do that in directories that will be found by your
    48 :setting:`STATICFILES_FINDERS` (by default, per-app ``static/`` subdirectories,
    49 and any directories you include in :setting:`STATICFILES_DIRS`). Files from
    50 those locations will be collected into :setting:`STATICFILES_ROOT`.
    51 
    52 .. setting:: STATICFILES_URL
    53 
    54 STATICFILES_URL
    55 ---------------
    56 
    57 Default: ``'/static/'``
    58 
    59 The URL that handles the files served from :setting:`STATICFILES_ROOT`, e.g.::
    60 
    61     STATICFILES_URL = '/site_media/static/'
    62 
    63 ... or perhaps::
    64 
    65     STATICFILES_URL = 'http://static.example.com/'
     26.. note::
    6627
    67 This should **always** have a trailing slash.
     28    The following settings control the behavior of the staticfiles app.
     29    Configuring the global settings :setting:`STATIC_ROOT` and
     30    :setting:`STATIC_URL` is **required**.
    6831
    6932.. setting:: STATICFILES_DIRS
    7033
    tuples, e.g.:: 
    9861
    9962With this configuration, the :djadmin:`collectstatic` management command would
    10063for example collect the stats files in a ``'downloads'`` directory. So
    101 assuming you have :setting:`STATICFILES_URL` set ``'/static/'``, this would
     64assuming you have :setting:`STATIC_URL` set ``'/static/'``, this would
    10265allow you to refer to the file ``'/opt/webfiles/stats/polls_20101022.tar.gz'``
    10366with ``'/static/downloads/polls_20101022.tar.gz'`` in your templates.
    10467
    collectstatic 
    160123
    161124.. django-admin:: collectstatic
    162125
    163 Collects the static files into :setting:`STATICFILES_ROOT`.
     126Collects the static files into :setting:`STATIC_ROOT`.
    164127
    165128Duplicate file names are by default resolved in a similar way to how template
    166129resolution works: the file that is first found in one of the specified
    collected for a given path. 
    223186Other Helpers
    224187=============
    225188
    226 The ``staticfiles`` context processor
    227 -------------------------------------
     189The ``static`` context processor
     190--------------------------------
    228191
    229 .. function:: django.contrib.staticfiles.context_processors.staticfiles
     192.. function:: django.core.context_processors.static
    230193
    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
    234 somewhere in your :setting:`TEMPLATE_CONTEXT_PROCESSORS` setting.
     194This context processor adds the :setting:`STATIC_URL` into each template
     195context as the variable ``{{ STATIC_URL }}``. To use it, make sure that
     196``'django.core.context_processors.static'`` appears somewhere in your
     197:setting:`TEMPLATE_CONTEXT_PROCESSORS` setting.
    235198
    236199Remember, only templates rendered with :class:`~django.template.RequestContext`
    237200will have acces to the data provided by this (and any) context processor.
    238201
    239 .. templatetag:: get_staticfiles_prefix
     202.. templatetag:: get_static_prefix
    240203
    241 The ``get_staticfiles_prefix`` templatetag
    242 ==========================================
     204The ``get_static_prefix`` templatetag
     205=====================================
    243206
    244207.. highlight:: html+django
    245208
    246209If 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
     210more control over exactly where and how :setting:`STATIC_URL` is injected
     211into the template, you can use the :ttag:`get_static_prefix` template tag
    249212instead::
    250213
    251     {% load staticfiles %}
    252     <img src="{% get_staticfiles_prefix %}images/hi.jpg" />
     214    {% load static %}
     215    <img src="{% get_static_prefix %}images/hi.jpg" />
    253216
    254217There's also a second form you can use to avoid extra processing if you need
    255218the value multiple times::
    256219
    257     {% load staticfiles %}
    258     {% get_staticfiles_prefix as STATIC_PREFIX %}
     220    {% load static %}
     221    {% get_static_prefix as STATIC_PREFIX %}
    259222
    260223    <img src="{{ STATIC_PREFIX }}images/hi.jpg" />
    261224    <img src="{{ STATIC_PREFIX }}images/hi2.jpg" />
    primary URL configuration:: 
    292255       )
    293256
    294257Note, the begin of the pattern (``r'^static/'``) should be your
    295 :setting:`STATICFILES_URL` setting.
     258:setting:`STATIC_URL` setting.
    296259
    297260Since this is a bit finicky, there's also a helper function that'll do this for you:
    298261
    already defined pattern list. Use it like this:: 
    307270
    308271   urlpatterns += staticfiles_urlpatterns()
    309272
     273.. warning::
     274
     275    This helper function will only work if :setting:`DEBUG` is ``True``
     276    and your :setting:`STATIC_URL` setting is neither empty nor a full
     277    URL such as ``http://static.example.com/``.
  • docs/ref/settings.txt

    diff --git a/docs/ref/settings.txt b/docs/ref/settings.txt
    index b394cd7..1632e0a 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
    Default: ``''`` (Empty string) 
    11221122URL that handles the media served from :setting:`MEDIA_ROOT`, used
    11231123for :doc:`managing stored files </topics/files>`.
    11241124
    1125 Example: ``"http://media.lawrence.com"``
     1125Example: ``"http://media.lawrence.com/"``
    11261126
    11271127Note that this should have a trailing slash if it has a path component.
    11281128
    1129  * Good: ``"http://www.example.com/static/"``
    1130  * Bad: ``"http://www.example.com/static"``
     1129 * Good: ``"http://www.example.com/media/"``
     1130 * Bad: ``"http://www.example.com/media"``
    11311131
    11321132MESSAGE_LEVEL
    11331133-------------
    See :doc:`/ref/contrib/sites`. 
    14861486
    14871487.. _site framework docs: ../sites/
    14881488
     1489.. setting:: STATIC_ROOT
     1490
     1491STATIC_ROOT
     1492-----------
     1493
     1494Default: ``''`` (Empty string)
     1495
     1496The absolute path to the directory that contains static content.
     1497
     1498Example: ``"/home/example.com/static/"``
     1499
     1500When using the :djadmin:`collectstatic` management command of the optional,
     1501:doc:`staticfiles</ref/contrib/staticfiles>` app this will be used to collect
     1502static files into and served from :setting:`STATIC_URL`.
     1503
     1504In that case this is a **required setting**, unless you've overridden
     1505:setting:`STATICFILES_STORAGE` and are using a custom storage backend.
     1506
     1507This is not a place to store your static files permanently under version
     1508control; you should do that in directories that will be found by your
     1509:setting:`STATICFILES_FINDERS` (by default, per-app ``static/`` subdirectories,
     1510and any directories you include in :setting:`STATICFILES_DIRS`). Files from
     1511those locations will be collected into :setting:`STATIC_ROOT`.
     1512
     1513See :doc:`/ref/contrib/staticfiles` and :setting:`STATIC_URL`.
     1514
     1515.. setting:: STATIC_URL
     1516
     1517STATIC_URL
     1518----------
     1519
     1520Default: ``'/static/'``
     1521
     1522URL that handles the files served from :setting:`STATIC_ROOT`.
     1523
     1524Example: ``"/site_media/static/"`` or ``"http://static.example.com/"``
     1525
     1526This is used in the :doc:`staticfiles app</ref/contrib/staticfiles>`.
     1527
     1528See :setting:`STATIC_ROOT`.
     1529
    14891530.. setting:: TEMPLATE_CONTEXT_PROCESSORS
    14901531
    14911532TEMPLATE_CONTEXT_PROCESSORS
    Default:: 
    14961537    ("django.contrib.auth.context_processors.auth",
    14971538    "django.core.context_processors.debug",
    14981539    "django.core.context_processors.i18n",
    1499     "django.contrib.staticfiles.context_processors.staticfiles",
     1540    "django.core.context_processors.media",
     1541    "django.core.context_processors.static",
    15001542    "django.contrib.messages.context_processors.messages")
    15011543
    15021544A tuple of callables that are used to populate the context in ``RequestContext``.
    of items to be merged into the context. 
    15131555    ``django.core.context_processors.auth`` to
    15141556    ``django.contrib.auth.context_processors.auth``.
    15151557
     1558.. versionadded:: 1.3
     1559    The ``django.core.context_processors.static`` context processor
     1560    was added in this release.
     1561
    15161562.. setting:: TEMPLATE_DEBUG
    15171563
    15181564TEMPLATE_DEBUG
  • docs/ref/templates/api.txt

    diff --git a/docs/ref/templates/api.txt b/docs/ref/templates/api.txt
    index aa4951e..e02debe 100644
    a b and return a dictionary of items to be merged into the context. By default, 
    312312    "django.core.context_processors.debug",
    313313    "django.core.context_processors.i18n",
    314314    "django.core.context_processors.media",
    315     "django.contrib.messages.context_processors.messages",
    316     "django.contrib.staticfiles.context_processors.staticfiles")
     315    "django.core.context_processors.static",
     316    "django.contrib.messages.context_processors.messages")
    317317
    318318.. versionadded:: 1.2
    319319   In addition to these, ``RequestContext`` always uses
    If :setting:`TEMPLATE_CONTEXT_PROCESSORS` contains this processor, every 
    435435``RequestContext`` will contain a variable ``MEDIA_URL``, providing the
    436436value of the :setting:`MEDIA_URL` setting.
    437437
     438django.core.context_processors.static
     439~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     440
     441.. versionadded:: 1.3
     442
     443If :setting:`TEMPLATE_CONTEXT_PROCESSORS` contains this processor, every
     444``RequestContext`` will contain a variable ``STATIC_URL``, providing the
     445value of the :setting:`STATIC_URL` setting.
     446
    438447django.core.context_processors.csrf
    439448~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    440449
  • 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..6cd581f 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 TestMiscFinder(TestCase): 
    372373            finders.get_finder, "django.contrib.staticfiles.finders.FooBarFinder")
    373374        self.assertRaises(ImproperlyConfigured,
    374375            finders.get_finder, "foo.bar.FooBarFinder")
    375 
    376 
    377 class TemplateTagTest(TestCase):
    378     def test_get_staticfiles_prefix(self):
    379         """
    380         Test the get_staticfiles_prefix helper return the STATICFILES_URL setting.
    381         """
    382         self.assertEquals(Template(
    383             "{% load staticfiles %}"
    384             "{% get_staticfiles_prefix %}"
    385         ).render(Context()), settings.STATICFILES_URL)
    386 
    387     def test_get_staticfiles_prefix_with_as(self):
    388         """
    389         Test the get_staticfiles_prefix helper return the STATICFILES_URL setting.
    390         """
    391         self.assertEquals(Template(
    392             "{% load staticfiles %}"
    393             "{% get_staticfiles_prefix as staticfiles_prefix %}"
    394             "{{ staticfiles_prefix }}"
    395         ).render(Context()), settings.STATICFILES_URL)
  • tests/regressiontests/templates/tests.py

    diff --git a/tests/regressiontests/templates/tests.py b/tests/regressiontests/templates/tests.py
    index 29171eb..ea93beb 100644
    a b class UTF8Class: 
    114114        return u'ŠĐĆŽćžšđ'.encode('utf-8')
    115115
    116116class Templates(unittest.TestCase):
     117    def setUp(self):
     118        self.old_static_url = settings.STATIC_URL
     119        self.old_media_url = settings.MEDIA_URL
     120        settings.STATIC_URL = u"/static/"
     121        settings.MEDIA_URL = u"/media/"
     122
     123    def tearDown(self):
     124        settings.STATIC_URL = self.old_static_url
     125        settings.MEDIA_URL = self.old_media_url
     126
    117127    def test_loaders_security(self):
    118128        ad_loader = app_directories.Loader()
    119129        fs_loader = filesystem.Loader()
    class Templates(unittest.TestCase): 
    13281338            'autoescape-filtertag01': ("{{ first }}{% filter safe %}{{ first }} x<y{% endfilter %}", {"first": "<a>"}, template.TemplateSyntaxError),
    13291339
    13301340            # ifqeual compares unescaped vales.
    1331             'autoescape-ifequal01': ('{% ifequal var "this & that" %}yes{% endifequal %}', { "var": "this & that" }, "yes" ),
     1341            'autoescape-ifequal01': ('{% ifequal var "this & that" %}yes{% endifequal %}', { "var": "this & that" }, "yes"),
    13321342
    13331343            # Arguments to filters are 'safe' and manipulate their input unescaped.
    13341344            'autoescape-filters01': ('{{ var|cut:"&" }}', { "var": "this & that" }, "this  that" ),
    1335             'autoescape-filters02': ('{{ var|join:" & \" }}', { "var": ("Tom", "Dick", "Harry") }, "Tom & Dick & Harry" ),
     1345            'autoescape-filters02': ('{{ var|join:" & \" }}', { "var": ("Tom", "Dick", "Harry") }, "Tom & Dick & Harry"),
    13361346
    13371347            # Literal strings are safe.
    1338             'autoescape-literals01': ('{{ "this & that" }}',{}, "this & that" ),
     1348            'autoescape-literals01': ('{{ "this & that" }}',{}, "this & that"),
    13391349
    13401350            # Iterating over strings outputs safe characters.
    1341             'autoescape-stringiterations01': ('{% for l in var %}{{ l }},{% endfor %}', {'var': 'K&R'}, "K,&amp;,R," ),
     1351            'autoescape-stringiterations01': ('{% for l in var %}{{ l }},{% endfor %}', {'var': 'K&R'}, "K,&amp;,R,"),
    13421352
    13431353            # Escape requirement survives lookup.
    1344             'autoescape-lookup01': ('{{ var.key }}', { "var": {"key": "this & that" }}, "this &amp; that" ),
     1354            'autoescape-lookup01': ('{{ var.key }}', { "var": {"key": "this & that" }}, "this &amp; that"),
    13451355
     1356            # Static template tags
     1357            'static-prefixtag01': ('{% load static %}{% get_static_prefix %}', {}, settings.STATIC_URL),
     1358            'static-prefixtag02': ('{% load static %}{% get_static_prefix as static_prefix %}{{ static_prefix }}', {}, settings.STATIC_URL),
     1359            'static-prefixtag03': ('{% load static %}{% get_media_prefix %}', {}, settings.MEDIA_URL),
     1360            'static-prefixtag04': ('{% load static %}{% get_media_prefix as media_prefix %}{{ media_prefix }}', {}, settings.MEDIA_URL),
    13461361        }
    13471362
    1348 
    13491363class TemplateTagLoading(unittest.TestCase):
    13501364
    13511365    def setUp(self):
Back to Top