Skip to content
This repository

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse code

Reworded parts of the staticfiles documentation after receiving vario…

…us user feedback. Thanks, all!

git-svn-id: http://code.djangoproject.com/svn/django/trunk@15369 bcc190cf-cafb-0310-a4f2-bffc1f526a37
  • Loading branch information...
commit 8fe42053bcec02769ae76b238d43086eb021ca89 1 parent e3d322e
Jannis Leidel authored January 30, 2011
203  docs/howto/static-files.txt
@@ -7,18 +7,19 @@ Managing static files
7 7
 .. versionadded:: 1.3
8 8
 
9 9
 Django developers mostly concern themselves with the dynamic parts of web
10  
-applications -- the views and templates that render anew for each request. But
11  
-web applications have other parts: the static media files (images, CSS,
  10
+applications -- the views and templates that render new for each request. But
  11
+web applications have other parts: the static files (images, CSS,
12 12
 Javascript, etc.) that are needed to render a complete web page.
13 13
 
14  
-For small projects, this isn't a big deal, because you can just keep the media
15  
-somewhere your web server can find it. However, in bigger projects -- especially
16  
-those comprised of multiple apps -- dealing with the multiple sets of static
17  
-files provided by each application starts to get tricky.
  14
+For small projects, this isn't a big deal, because you can just keep the
  15
+static files somewhere your web server can find it. However, in bigger
  16
+projects -- especially those comprised of multiple apps -- dealing with the
  17
+multiple sets of static files provided by each application starts to get
  18
+tricky.
18 19
 
19  
-That's what ``django.contrib.staticfiles`` is for: it collects media from each
20  
-of your applications (and any other places you specify) into a single location
21  
-that can easily be served in production.
  20
+That's what ``django.contrib.staticfiles`` is for: it collects static files
  21
+from each of your applications (and any other places you specify) into a
  22
+single location that can easily be served in production.
22 23
 
23 24
 .. note::
24 25
 
@@ -37,51 +38,56 @@ Using ``django.contrib.staticfiles``
37 38
 
38 39
 Here's the basic usage in a nutshell:
39 40
 
40  
-    1. Put your media somewhere that staticfiles will find it.
  41
+    1. Put your static files somewhere that staticfiles will find it.
41 42
 
42  
-       Most of the time this place will be in a ``static`` directory within your
43  
-       application, but it could also be a specific directory you've put into
44  
-       your settings file. See the the documentation for the
  43
+       Most of the time this place will be in a ``static`` directory within
  44
+       your application, but it could also be a specific directory you've put
  45
+       into your settings file. See the the documentation for the
45 46
        :setting:`STATICFILES_DIRS` and :setting:`STATICFILES_FINDERS` settings
46  
-       for details on where you can put media.
  47
+       for details on where you can put static files.
47 48
 
48 49
     2. Add some ``staticfiles``-related settings to your settings file.
49 50
 
50  
-       First, you'll need to make sure that ``django.contrib.staticfiles`` is in
51  
-       your :setting:`INSTALLED_APPS`.
  51
+       First, you'll need to make sure that ``django.contrib.staticfiles``
  52
+       is in your :setting:`INSTALLED_APPS`.
52 53
 
53  
-       Next, you'll need to edit :setting:`STATIC_ROOT` to point to where
54  
-       you'd like your static media stored. For example::
  54
+       Next, you'll need to set the :setting:`STATIC_URL` setting, though
  55
+       the default value (of ``'/static/'``) is perfect for local development.
  56
+       See also the :setting:`STATIC_URL` documentation.
55 57
 
56  
-            STATIC_ROOT = "/home/jacob/projects/mysite.com/static_media"
  58
+       Then, edit the :setting:`STATIC_ROOT` setting to point to where
  59
+       you'd like your static files collected at (when using the
  60
+       :djadmin:`collectstatic`, see below). For example::
57 61
 
58  
-       You may also want to set the :setting:`STATIC_URL` setting at this
59  
-       time, though the default value (of ``/static/``) is perfect for local
60  
-       development.
  62
+            STATIC_ROOT = "/home/jacob/projects/mysite.com/sitestatic"
61 63
 
62  
-       There are a number of other options available that let you control *how*
63  
-       media is stored, where ``staticfiles`` searches for files, and how files
64  
-       will be served; see :ref:`the staticfiles settings reference
65  
-       <staticfiles-settings>` for details.
  64
+       There are a number of other options available that let you control
  65
+       *how* static files are stored, where ``staticfiles`` searches for
  66
+       files, and how files will be served; see :ref:`the staticfiles
  67
+       settings reference <staticfiles-settings>` for details.
66 68
 
67 69
     3. Run the :djadmin:`collectstatic` management command::
68 70
 
69 71
             ./manage.py collectstatic
70 72
 
71 73
        This'll churn through your static file storage and move them into the
72  
-       directory given by :setting:`STATIC_ROOT`. (This is not necessary
73  
-       in local development if you are using :djadmin:`runserver` or adding
74  
-       ``staticfiles_urlpatterns`` to your URLconf; see below).
  74
+       directory given by :setting:`STATIC_ROOT`.
75 75
 
76  
-    4. Deploy that media.
  76
+       .. note:: This is **not necessary in local development** if you are
  77
+           using :djadmin:`staticfiles-runserver` or adding
  78
+           ``staticfiles_urlpatterns`` to your URLconf; see below).
  79
+
  80
+    4. Deploy those files.
77 81
 
78 82
        If you're using the built-in development server (the
79 83
        :djadmin:`runserver` management command) and have the :setting:`DEBUG`
80 84
        setting set to ``True``, your staticfiles will automatically be served
81  
-       from :setting:`STATIC_URL` in development.
  85
+       from :setting:`STATIC_URL` in development. You don't need to run
  86
+       :djadmin:`collectstatic` in that case because ``staticfiles``'s
  87
+       runserver command handle the serving of static files.
82 88
 
83  
-       If you are using some other server for local development, you can
84  
-       quickly serve static media locally by adding::
  89
+       But, in case you are using some other server for local development,
  90
+       you can quickly serve static files locally by adding::
85 91
 
86 92
             from django.contrib.staticfiles.urls import staticfiles_urlpatterns
87 93
             urlpatterns += staticfiles_urlpatterns()
@@ -113,11 +119,11 @@ the framework see :doc:`the staticfiles reference </ref/contrib/staticfiles>`.
113 119
    :setting:`MEDIA_ROOT` along with user-uploaded files, and serve them both at
114 120
    :setting:`MEDIA_URL`. Part of the purpose of introducing the ``staticfiles``
115 121
    app is to make it easier to keep static files separate from user-uploaded
116  
-   files. For this reason, you will probably want to make your
117  
-   :setting:`MEDIA_ROOT` and :setting:`MEDIA_URL` different from your
118  
-   :setting:`STATIC_ROOT` and :setting:`STATIC_URL`. You will need to
119  
-   arrange for serving of files in :setting:`MEDIA_ROOT` yourself;
120  
-   ``staticfiles`` does not deal with user-uploaded media at all.
  122
+   files. For this reason, you need to make your :setting:`MEDIA_ROOT` and
  123
+   :setting:`MEDIA_URL` different from your :setting:`STATIC_ROOT` and
  124
+   :setting:`STATIC_URL`. You will need to arrange for serving of files in
  125
+   :setting:`MEDIA_ROOT` yourself; ``staticfiles`` does not deal with
  126
+   user-uploaded files at all.
121 127
 
122 128
 .. _staticfiles-in-templates:
123 129
 
@@ -129,16 +135,17 @@ You could, of course, simply hardcode the path to you assets in the templates:
129 135
 
130 136
 .. code-block:: html
131 137
 
132  
-    <img src="http://media.example.com/static/myimage.jpg" />
  138
+    <img src="http://static.example.com/static/myimage.jpg" />
133 139
 
134 140
 Of course, there are some serious problems with this: it doesn't work well in
135 141
 development, and it makes it *very* hard to change where you've deployed your
136  
-media. If, for example, you wanted to switch to using a content delivery network
137  
-(CDN), then you'd need to change more or less every single template.
  142
+static files. If, for example, you wanted to switch to using a content
  143
+delivery network (CDN), then you'd need to change more or less every single
  144
+template.
138 145
 
139 146
 A far better way is to use the value of the :setting:`STATIC_URL` setting
140  
-directly in your templates. This means that a switch of media servers only
141  
-requires changing that single value. Much better!
  147
+directly in your templates. This means that a switch of static files servers
  148
+only requires changing that single value. Much better!
142 149
 
143 150
 ``staticfiles`` inludes two built-in ways of getting at this setting in your
144 151
 templates: a context processor and a template tag.
@@ -206,18 +213,19 @@ value multiple times:
206 213
 Serving static files in development
207 214
 ===================================
208 215
 
209  
-The static files tools are mostly designed to help with getting static media
210  
-successfully deployed into production. This usually means a separate, dedicated
211  
-media server, which is a lot of overhead to mess with when developing locally.
212  
-Thus, the ``staticfiles`` app ships with a quick and dirty helper view that you
213  
-can use to serve files locally in development.
  216
+The static files tools are mostly designed to help with getting static files
  217
+successfully deployed into production. This usually means a separate,
  218
+dedicated static file server, which is a lot of overhead to mess with when
  219
+developing locally. Thus, the ``staticfiles`` app ships with a
  220
+**quick and dirty helper view** that you can use to serve files locally in
  221
+development.
214 222
 
215 223
 This view is automatically enabled and will serve your static files at
216 224
 :setting:`STATIC_URL` when you use the built-in :djadmin:`runserver`.
217 225
 
218 226
 To enable this view if you are using some other server for local development,
219  
-you'll add a couple of lines to your URLconf. The first line goes at the top of
220  
-the file, and the last line at the bottom::
  227
+you'll add a couple of lines to your URLconf. The first line goes at the top
  228
+of the file, and the last line at the bottom::
221 229
 
222 230
     from django.contrib.staticfiles.urls import staticfiles_urlpatterns
223 231
 
@@ -225,11 +233,11 @@ the file, and the last line at the bottom::
225 233
 
226 234
     urlpatterns += staticfiles_urlpatterns()
227 235
 
228  
-This will inspect your :setting:`STATIC_URL` and
229  
-:setting:`STATIC_ROOT` settings and wire up the view to serve static media
230  
-accordingly. Don't forget to set the :setting:`STATICFILES_DIRS` setting
231  
-appropriately to let ``django.contrib.staticfiles`` know where to look for
232  
-(additional) files.
  236
+This will inspect your :setting:`STATIC_URL` setting and wire up the view
  237
+to serve static files accordingly. Don't forget to set the
  238
+:setting:`STATICFILES_DIRS` setting appropriately to let
  239
+``django.contrib.staticfiles`` know where to look for files additionally to
  240
+files in app directories.
233 241
 
234 242
 .. warning::
235 243
 
@@ -239,8 +247,9 @@ appropriately to let ``django.contrib.staticfiles`` know where to look for
239 247
     **insecure**. This is only intended for local development, and should
240 248
     **never be used in production**.
241 249
 
242  
-    Additionally, your :setting:`STATIC_URL` setting can't be either empty
243  
-    or a full URL such as ``http://static.example.com/``.
  250
+    Additionally, when using ``staticfiles_urlpatterns`` your
  251
+    :setting:`STATIC_URL` setting can't be empty or a full URL, such as
  252
+    ``http://static.example.com/``.
244 253
 
245 254
 For a few more details, including an alternate method of enabling this view,
246 255
 see :ref:`staticfiles-development-view`.
@@ -251,9 +260,9 @@ Serving static files in production
251 260
 ==================================
252 261
 
253 262
 The basic outline of putting static files into production is simple: run the
254  
-:djadmin:`collectstatic` command when static media changes, then arrange for the
255  
-collected media directory (:setting:`STATIC_ROOT`) to be moved to the media
256  
-server and served.
  263
+:djadmin:`collectstatic` command when static files change, then arrange for
  264
+the collected static files directory (:setting:`STATIC_ROOT`) to be moved to
  265
+the static file server and served.
257 266
 
258 267
 Of course, as with all deployment tasks, the devil's in the details. Every
259 268
 production setup will be a bit different, so you'll need to adapt the basic
@@ -262,30 +271,30 @@ outline to fit your needs. Below are a few common patterns that might help.
262 271
 Serving the app and your static files from the same server
263 272
 ----------------------------------------------------------
264 273
 
265  
-If you want to serve your media from the same server that's already serving your
266  
-app, the basic outline gets modified to look something like:
  274
+If you want to serve your static files from the same server that's already
  275
+serving your site, the basic outline gets modified to look something like:
267 276
 
268 277
     * Push your code up to the deployment server.
269  
-    * On the server, run :djadmin:`collectstatic` to move all the media into
270  
-      :setting:`STATIC_ROOT`.
  278
+    * On the server, run :djadmin:`collectstatic` to move all the static files
  279
+      into :setting:`STATIC_ROOT`.
271 280
     * Point your web server at :setting:`STATIC_ROOT`. For example, here's
272 281
       :ref:`how to do this under Apache and mod_wsgi <serving-media-files>`.
273 282
 
274  
-You'll probably want to automate this process, especially if you've got multiple
275  
-web servers. There's any number of ways to do this automation, but one option
276  
-that many Django developers enjoy is `Fabric`__.
  283
+You'll probably want to automate this process, especially if you've got
  284
+multiple web servers. There's any number of ways to do this automation, but
  285
+one option that many Django developers enjoy is `Fabric`__.
277 286
 
278 287
 __ http://fabfile.org/
279 288
 
280 289
 Below, and in the following sections, we'll show off a few example fabfiles
281  
-(i.e. Fabric scripts) that automate these media deployment options. The syntax
  290
+(i.e. Fabric scripts) that automate these file deployment options. The syntax
282 291
 of a fabfile is fairly straightforward but won't be covered here; consult
283 292
 `Fabric's documentation`__, for a complete explanation of the syntax..
284 293
 
285 294
 __ http://docs.fabfile.org/
286 295
 
287  
-So, a fabfile to deploy media to a couple of web servers might look something
288  
-like::
  296
+So, a fabfile to deploy static files to a couple of web servers might look
  297
+something like::
289 298
 
290 299
     from fabric.api import *
291 300
 
@@ -299,12 +308,12 @@ like::
299 308
         with cd(env.project_root):
300 309
             run('./manage.py collectstatic -v0 --noinput')
301 310
 
302  
-Serving static files from a dedicated media server
303  
---------------------------------------------------
  311
+Serving static files from a dedicated server
  312
+--------------------------------------------
304 313
 
305 314
 Most larger Django apps use a separate Web server -- i.e., one that's not also
306  
-running Django -- for serving media. This server often runs a different type of
307  
-web server -- faster but less full-featured. Some good choices are:
  315
+running Django -- for serving static files. This server often runs a different
  316
+type of web server -- faster but less full-featured. Some good choices are:
308 317
 
309 318
     * lighttpd_
310 319
     * Nginx_
@@ -318,17 +327,17 @@ web server -- faster but less full-featured. Some good choices are:
318 327
 .. _Apache: http://httpd.apache.org/
319 328
 .. _Cherokee: http://www.cherokee-project.com/
320 329
 
321  
-Configuring these servers is out of scope of this document; check each server's
322  
-respective documentation for instructions.
  330
+Configuring these servers is out of scope of this document; check each
  331
+server's respective documentation for instructions.
323 332
 
324  
-Since your media server won't be running Django, you'll need to modify the
325  
-deployment strategy to look something like:
  333
+Since your static file server won't be running Django, you'll need to modify
  334
+the deployment strategy to look something like:
326 335
 
327  
-    * When your media changes, run :djadmin:`collectstatic` locally.
328  
-    * Push your local :setting:`STATIC_ROOT` up to the media server
  336
+    * When your static files change, run :djadmin:`collectstatic` locally.
  337
+    * Push your local :setting:`STATIC_ROOT` up to the static file server
329 338
       into the directory that's being served. ``rsync`` is a good
330 339
       choice for this step since it only needs to transfer the
331  
-      bits of static media that have changed.
  340
+      bits of static files that have changed.
332 341
 
333 342
 Here's how this might look in a fabfile::
334 343
 
@@ -339,9 +348,9 @@ Here's how this might look in a fabfile::
339 348
     env.local_static_root = '/tmp/static'
340 349
 
341 350
     # Where the static files should go remotely
342  
-    env.remote_static_root = '/home/www/media.example.com'
  351
+    env.remote_static_root = '/home/www/static.example.com'
343 352
 
344  
-    @roles('media')
  353
+    @roles('static')
345 354
     def deploy_static():
346 355
         local('./manage.py collectstatic')
347 356
         project.rysnc_project(
@@ -352,17 +361,17 @@ Here's how this might look in a fabfile::
352 361
 
353 362
 .. _staticfiles-from-cdn:
354 363
 
355  
-Serving static media from a cloud service or CDN
  364
+Serving static files from a cloud service or CDN
356 365
 ------------------------------------------------
357 366
 
358  
-Another common tactic is to serve media from a cloud storage provider like
359  
-Amazon's S3__ and/or a CDN (content delivery network). This lets you ignore the
360  
-problems of serving media, and can often make for faster-loading webpages
361  
-(especially when using a CDN).
  367
+Another common tactic is to serve static files from a cloud storage provider
  368
+like Amazon's S3__ and/or a CDN (content delivery network). This lets you
  369
+ignore the problems of serving static files, and can often make for
  370
+faster-loading webpages (especially when using a CDN).
362 371
 
363 372
 When using these services, the basic workflow would look a bit like the above,
364  
-except that instead of using ``rsync`` to transfer your media to the server
365  
-you'd need to transfer the media to the storage provider or CDN.
  373
+except that instead of using ``rsync`` to transfer your static files to the
  374
+server you'd need to transfer the static files to the storage provider or CDN.
366 375
 
367 376
 There's any number of ways you might do this, but if the provider has an API a
368 377
 :doc:`custom file storage backend </howto/custom-file-storage>` will make the
@@ -376,9 +385,9 @@ For example, if you've written an S3 storage backend in
376 385
     STATICFILES_STORAGE = 'myproject.storage.S3Storage'
377 386
 
378 387
 Once that's done, all you have to do is run :djadmin:`collectstatic` and your
379  
-media would be pushed through your storage package up to S3. If you later needed
380  
-to swich to a different storage provider, it could be as simple as changing your
381  
-:setting:`STATICFILES_STORAGE` setting.
  388
+static files would be pushed through your storage package up to S3. If you
  389
+later needed to swich to a different storage provider, it could be as simple
  390
+as changing your :setting:`STATICFILES_STORAGE` setting.
382 391
 
383 392
 For details on how you'd write one of these backends,
384 393
 :doc:`/howto/custom-file-storage`.
@@ -396,8 +405,8 @@ Upgrading from ``django-staticfiles``
396 405
 =====================================
397 406
 
398 407
 ``django.contrib.staticfiles`` began its life as `django-staticfiles`_. If
399  
-you're upgrading from `django-staticfiles`_ to ``django.contrib.staticfiles``,
400  
-you'll need to make a few changes:
  408
+you're upgrading from `django-staticfiles`_ < ``1.0``` (e.g. ``0.3.4``) to
  409
+``django.contrib.staticfiles``, you'll need to make a few changes:
401 410
 
402 411
     * Application files should now live in a ``static`` directory in each app
403 412
       (`django-staticfiles`_ used the name ``media``, which was slightly
@@ -410,8 +419,8 @@ you'll need to make a few changes:
410 419
       ``STATICFILES_MEDIA_DIRNAMES`` and ``STATICFILES_EXCLUDED_APPS`` were
411 420
       removed.
412 421
 
413  
-    * The setting ``STATICFILES_RESOLVERS`` was removed, and replaced by the new
414  
-      :setting:`STATICFILES_FINDERS`.
  422
+    * The setting ``STATICFILES_RESOLVERS`` was removed, and replaced by the
  423
+      new :setting:`STATICFILES_FINDERS`.
415 424
 
416 425
     * The default for :setting:`STATICFILES_STORAGE` was renamed from
417 426
       ``staticfiles.storage.StaticFileStorage`` to
23  docs/ref/contrib/staticfiles.txt
@@ -50,20 +50,29 @@ your additional files directory(ies) e.g.::
50 50
         "/opt/webfiles/common",
51 51
     )
52 52
 
  53
+Prefixes (optional)
  54
+"""""""""""""""""""
  55
+
53 56
 In case you want to refer to files in one of the locations with an additional
54 57
 namespace, you can **optionally** provide a prefix as ``(prefix, path)``
55 58
 tuples, e.g.::
56 59
 
57 60
     STATICFILES_DIRS = (
58  
-        "/home/polls.com/polls/static",
  61
+        # ...
59 62
         ("downloads", "/opt/webfiles/stats"),
60 63
     )
61 64
 
62  
-With this configuration, the :djadmin:`collectstatic` management command would
63  
-for example collect the stats files in a ``'downloads'`` directory. So
64  
-assuming you have :setting:`STATIC_URL` set ``'/static/'``, this would
65  
-allow you to refer to the file ``'/opt/webfiles/stats/polls_20101022.tar.gz'``
66  
-with ``'/static/downloads/polls_20101022.tar.gz'`` in your templates.
  65
+Example:
  66
+
  67
+Assuming you have :setting:`STATIC_URL` set ``'/static/'``, the
  68
+:djadmin:`collectstatic` management command would collect the "stats" files
  69
+in a ``'downloads'`` subdirectory of :setting:`STATIC_ROOT`.
  70
+
  71
+This would allow you to refer to the local file
  72
+``'/opt/webfiles/stats/polls_20101022.tar.gz'`` with
  73
+``'/static/downloads/polls_20101022.tar.gz'`` in your templates, e.g.::
  74
+
  75
+    <a href="{{ STATIC_URL }}downloads/polls_20101022.tar.gz">
67 76
 
68 77
 .. setting:: STATICFILES_STORAGE
69 78
 
@@ -183,6 +192,8 @@ collected for a given path.
183 192
 runserver
184 193
 ---------
185 194
 
  195
+.. django-admin:: staticfiles-runserver
  196
+
186 197
 Overrides the core :djadmin:`runserver` command if the ``staticfiles`` app
187 198
 is :setting:`installed<INSTALLED_APPS>` and adds automatic serving of static
188 199
 files and the following new options.
29  docs/ref/settings.txt
@@ -1628,24 +1628,25 @@ STATIC_ROOT
1628 1628
 
1629 1629
 Default: ``''`` (Empty string)
1630 1630
 
1631  
-The absolute path to the directory that contains static content.
  1631
+The absolute path to the directory that contains static files.
1632 1632
 
1633 1633
 Example: ``"/home/example.com/static/"``
1634 1634
 
1635  
-When using the :djadmin:`collectstatic` management command of the optional,
1636  
-:doc:`staticfiles</ref/contrib/staticfiles>` app this will be used to collect
1637  
-static files into and served from :setting:`STATIC_URL`.
  1635
+If the :doc:`staticfiles</ref/contrib/staticfiles>` contrib app is enabled
  1636
+(default) this will be used as the directory which the
  1637
+:djadmin:`collectstatic` management command collects static files in. See
  1638
+the howto on :doc:`managing static files</howto/static-files>` for more
  1639
+details about usage.
1638 1640
 
1639  
-In that case this is a **required setting**, unless you've overridden
1640  
-:setting:`STATICFILES_STORAGE` and are using a custom storage backend.
  1641
+.. warning:: This is not a place to store your static files permanently;
  1642
+    you should do that in directories that will be found by
  1643
+    :doc:`staticfiles</ref/contrib/staticfiles>`'s
  1644
+    :setting:`finders<STATICFILES_FINDERS>`, which by default, are
  1645
+    ``'static'`` app sub directories and any directories you include in
  1646
+    the :setting:`STATICFILES_DIRS`).
1641 1647
 
1642  
-This is not a place to store your static files permanently under version
1643  
-control; you should do that in directories that will be found by your
1644  
-:setting:`STATICFILES_FINDERS` (by default, per-app ``static/`` subdirectories,
1645  
-and any directories you include in :setting:`STATICFILES_DIRS`). Files from
1646  
-those locations will be collected into :setting:`STATIC_ROOT`.
1647  
-
1648  
-See :doc:`/ref/contrib/staticfiles` and :setting:`STATIC_URL`.
  1648
+See :doc:`staticfiles reference</ref/contrib/staticfiles>` and
  1649
+:setting:`STATIC_URL`.
1649 1650
 
1650 1651
 .. setting:: STATIC_URL
1651 1652
 
@@ -1654,7 +1655,7 @@ STATIC_URL
1654 1655
 
1655 1656
 Default: ``None``
1656 1657
 
1657  
-URL that handles the files served from :setting:`STATIC_ROOT`.
  1658
+URL to use when referring to static files located in :setting:`STATIC_ROOT`.
1658 1659
 
1659 1660
 Example: ``"/site_media/static/"`` or ``"http://static.example.com/"``
1660 1661
 
2  docs/topics/forms/media.txt
@@ -204,7 +204,7 @@ the appropriate prefix.
204 204
 
205 205
 As part of the introduction of the
206 206
 :doc:`staticfiles app </ref/contrib/staticfiles>` two new settings were added
207  
-to refer to "static content" (images, CSS, Javascript, etc.) that are needed
  207
+to refer to "static files" (images, CSS, Javascript, etc.) that are needed
208 208
 to render a complete web page: :setting:`STATIC_URL` and :setting:`STATIC_ROOT`.
209 209
 
210 210
 To find the appropriate prefix to use, Django will check if the

0 notes on commit 8fe4205

Please sign in to comment.
Something went wrong with that request. Please try again.