Merge remote-tracking branch 'core/master' into schema-alteration

Conflicts:
	django/db/models/fields/related.py

6 files changed, 53 insertions, 18 deletions

diff --git a/docs/intro/overview.txt b/docs/intro/overview.txt
index 8753817256..77838ffcaa 100644
--- a/docs/intro/overview.txt
+++ b/docs/intro/overview.txt
@@ -16,14 +16,18 @@ Design your model
 =================
 
 Although you can use Django without a database, it comes with an
-object-relational mapper in which you describe your database layout in Python
+`object-relational mapper`_ in which you describe your database layout in Python
 code.
 
+.. _object-relational mapper: http://en.wikipedia.org/wiki/Object-relational_mapping
+
 The :doc:`data-model syntax </topics/db/models>` offers many rich ways of
 representing your models -- so far, it's been solving two years' worth of
 database-schema problems. Here's a quick example, which might be saved in
 the file ``mysite/news/models.py``::
 
+    from django.db import models
+
     class Reporter(models.Model):
         full_name = models.CharField(max_length=70)
 
@@ -55,8 +59,9 @@ tables in your database for whichever tables don't already exist.
 Enjoy the free API
 ==================
 
-With that, you've got a free, and rich, :doc:`Python API </topics/db/queries>` to
-access your data. The API is created on the fly, no code generation necessary:
+With that, you've got a free, and rich, :doc:`Python API </topics/db/queries>`
+to access your data. The API is created on the fly, no code generation
+necessary:
 
 .. code-block:: python
 
@@ -133,9 +138,9 @@ A dynamic admin interface: it's not just scaffolding -- it's the whole house
 ============================================================================
 
 Once your models are defined, Django can automatically create a professional,
-production ready :doc:`administrative interface </ref/contrib/admin/index>` -- a Web
-site that lets authenticated users add, change and delete objects. It's as easy
-as registering your model in the admin site::
+production ready :doc:`administrative interface </ref/contrib/admin/index>` --
+a Web site that lets authenticated users add, change and delete objects. It's
+as easy as registering your model in the admin site::
 
     # In models.py...
 
@@ -171,9 +176,9 @@ application. Django encourages beautiful URL design and doesn't put any cruft
 in URLs, like ``.php`` or ``.asp``.
 
 To design URLs for an app, you create a Python module called a :doc:`URLconf
-</topics/http/urls>`. A table of contents for your app, it contains a simple mapping
-between URL patterns and Python callback functions. URLconfs also serve to
-decouple URLs from Python code.
+</topics/http/urls>`. A table of contents for your app, it contains a simple
+mapping between URL patterns and Python callback functions. URLconfs also serve
+to decouple URLs from Python code.
 
 Here's what a URLconf might look like for the ``Reporter``/``Article``
 example above::
@@ -186,7 +191,7 @@ example above::
         (r'^articles/(\d{4})/(\d{2})/(\d+)/$', 'news.views.article_detail'),
     )
 
-The code above maps URLs, as simple regular expressions, to the location of
+The code above maps URLs, as simple `regular expressions`_, to the location of
 Python callback functions ("views"). The regular expressions use parenthesis to
 "capture" values from the URLs. When a user requests a page, Django runs
 through each pattern, in order, and stops at the first one that matches the
@@ -194,6 +199,8 @@ requested URL. (If none of them matches, Django calls a special-case 404 view.)
 This is blazingly fast, because the regular expressions are compiled at load
 time.
 
+.. _regular expressions: http://docs.python.org/2/howto/regex.html
+
 Once one of the regexes matches, Django imports and calls the given view, which
 is a simple Python function. Each view gets passed a request object --
 which contains request metadata -- and the values captured in the regex.
@@ -214,6 +221,8 @@ Generally, a view retrieves data according to the parameters, loads a template
 and renders the template with the retrieved data. Here's an example view for
 ``year_archive`` from above::
 
+    from django.shortcuts import render_to_response
+
     def year_archive(request, year):
         a_list = Article.objects.filter(pub_date__year=year)
         return render_to_response('news/year_archive.html', {'year': year, 'article_list': a_list})
@@ -229,8 +238,8 @@ The code above loads the ``news/year_archive.html`` template.
 
 Django has a template search path, which allows you to minimize redundancy among
 templates. In your Django settings, you specify a list of directories to check
-for templates. If a template doesn't exist in the first directory, it checks the
-second, and so on.
+for templates with :setting:`TEMPLATE_DIRS`. If a template doesn't exist in the
+first directory, it checks the second, and so on.
 
 Let's say the ``news/year_archive.html`` template was found. Here's what that
 might look like:
@@ -261,9 +270,10 @@ character). This is called a template filter, and it's a way to filter the value
 of a variable. In this case, the date filter formats a Python datetime object in
 the given format (as found in PHP's date function).
 
-You can chain together as many filters as you'd like. You can write custom
-filters. You can write custom template tags, which run custom Python code behind
-the scenes.
+You can chain together as many filters as you'd like. You can write :ref:`custom
+template filters <howto-writing-custom-template-filters>`. You can write
+:doc:`custom template tags </howto/custom-template-tags>`, which run custom
+Python code behind the scenes.
 
 Finally, Django uses the concept of "template inheritance": That's what the
 ``{% extends "base.html" %}`` does. It means "First load the template called
diff --git a/docs/intro/tutorial01.txt b/docs/intro/tutorial01.txt
index d623bd8451..6e5988b15a 100644
--- a/docs/intro/tutorial01.txt
+++ b/docs/intro/tutorial01.txt
@@ -582,6 +582,8 @@ of this object. Let's fix that by editing the polls model (in the
 ``Choice``. On Python 3, simply replace ``__unicode__`` by ``__str__`` in the
 following example::
 
+    from django.db import models
+
     class Poll(models.Model):
         # ...
         def __unicode__(self):  # Python 3: def __str__(self):
diff --git a/docs/intro/tutorial02.txt b/docs/intro/tutorial02.txt
index 1987c51a67..dd3e86d8ae 100644
--- a/docs/intro/tutorial02.txt
+++ b/docs/intro/tutorial02.txt
@@ -158,6 +158,9 @@ you want when you register the object.
 Let's see how this works by re-ordering the fields on the edit form. Replace
 the ``admin.site.register(Poll)`` line with::
 
+    from django.contrib import admin
+    from polls.models import Poll
+
     class PollAdmin(admin.ModelAdmin):
         fields = ['pub_date', 'question']
 
@@ -179,6 +182,9 @@ of fields, choosing an intuitive order is an important usability detail.
 And speaking of forms with dozens of fields, you might want to split the form
 up into fieldsets::
 
+    from django.contrib import admin
+    from polls.models import Poll
+
     class PollAdmin(admin.ModelAdmin):
         fieldsets = [
             (None,               {'fields': ['question']}),
@@ -198,6 +204,9 @@ You can assign arbitrary HTML classes to each fieldset. Django provides a
 This is useful when you have a long form that contains a number of fields that
 aren't commonly used::
 
+        from django.contrib import admin
+        from polls.models import Poll
+
         class PollAdmin(admin.ModelAdmin):
             fieldsets = [
                 (None,               {'fields': ['question']}),
@@ -218,6 +227,7 @@ Yet.
 There are two ways to solve this problem. The first is to register ``Choice``
 with the admin just as we did with ``Poll``. That's easy::
 
+    from django.contrib import admin
     from polls.models import Choice
 
     admin.site.register(Choice)
@@ -342,6 +352,12 @@ representation of the output.
 You can improve that by giving that method (in :file:`polls/models.py`) a few
 attributes, as follows::
 
+    import datetime
+    from django.utils import timezone
+    from django.db import models
+
+    from polls.models import Poll
+
     class Poll(models.Model):
         # ...
         def was_published_recently(self):
diff --git a/docs/intro/tutorial03.txt b/docs/intro/tutorial03.txt
index 86cc5f97e6..120369172e 100644
--- a/docs/intro/tutorial03.txt
+++ b/docs/intro/tutorial03.txt
@@ -336,7 +336,7 @@ Put the following code in that template:
         <p>No polls are available.</p>
     {% endif %}
 
-Now let's use that html template in our index view::
+Now let's update our ``index`` view in ``polls/views.py`` to use the template::
 
     from django.http import HttpResponse
     from django.template import Context, loader
@@ -393,6 +393,9 @@ Now, let's tackle the poll detail view -- the page that displays the question
 for a given poll. Here's the view::
 
     from django.http import Http404
+    from django.shortcuts import render
+
+    from polls.models import Poll
     # ...
     def detail(request, poll_id):
         try:
@@ -420,6 +423,8 @@ and raise :exc:`~django.http.Http404` if the object doesn't exist. Django
 provides a shortcut. Here's the ``detail()`` view, rewritten::
 
     from django.shortcuts import render, get_object_or_404
+
+    from polls.models import Poll
     # ...
     def detail(request, poll_id):
         poll = get_object_or_404(Poll, pk=poll_id)
diff --git a/docs/intro/tutorial04.txt b/docs/intro/tutorial04.txt
index 9f54243a3e..f81a7d6758 100644
--- a/docs/intro/tutorial04.txt
+++ b/docs/intro/tutorial04.txt
@@ -136,6 +136,8 @@ object. For more on :class:`~django.http.HttpRequest` objects, see the
 After somebody votes in a poll, the ``vote()`` view redirects to the results
 page for the poll. Let's write that view::
 
+    from django.shortcuts import get_object_or_404, render
+
     def results(request, poll_id):
         poll = get_object_or_404(Poll, pk=poll_id)
         return render(request, 'polls/results.html', {'poll': poll})
diff --git a/docs/intro/tutorial05.txt b/docs/intro/tutorial05.txt
index a276763d67..39c3785f7c 100644
--- a/docs/intro/tutorial05.txt
+++ b/docs/intro/tutorial05.txt
@@ -503,8 +503,8 @@ of the process of creating polls.
 message: "No polls are available." and verifies the ``latest_poll_list`` is
 empty. Note that the :class:`django.test.TestCase` class provides some
 additional assertion methods. In these examples, we use
-:meth:`~django.test.TestCase.assertContains()` and
-:meth:`~django.test.TestCase.assertQuerysetEqual()`.
+:meth:`~django.test.SimpleTestCase.assertContains()` and
+:meth:`~django.test.TransactionTestCase.assertQuerysetEqual()`.
 
 In ``test_index_view_with_a_past_poll``, we create a poll and verify that it
 appears in the list.