Context Navigation

Back to Ticket #11509

Ticket #11509: 11509.2.diff

File 11509.2.diff, 32.9 KB (added by Tim Graham, 14 years ago)
update to apply cleanly to trunk

docs/howto/jython.txt

From efefe283b861da61c75961b1db8f6e9af7dcc89e Mon Sep 17 00:00:00 2001
From: Derek Willis <dwillis@gmail.com>
Date: Tue, 21 Sep 2010 20:35:49 -0400
Subject: [PATCH] changed web to Web and website to Web site in various places

---
 docs/howto/jython.txt                              |    2 +-
 docs/internals/committers.txt                      |    4 ++--
 docs/internals/svn.txt                             |    6 +++---
 docs/intro/index.txt                               |    2 +-
 docs/intro/whatsnext.txt                           |    4 ++--
 docs/misc/api-stability.txt                        |    2 +-
 docs/ref/contrib/gis/deployment.txt                |    2 +-
 docs/ref/contrib/gis/index.txt                     |    4 ++--
 docs/ref/contrib/gis/install.txt                   |    6 +++---
 docs/ref/contrib/gis/model-api.txt                 |    4 ++--
 docs/ref/contrib/gis/tutorial.txt                  |    8 ++++----
 docs/ref/contrib/gis/utils.txt                     |    2 +-
 docs/ref/contrib/sites.txt                         |    2 +-
 docs/ref/forms/widgets.txt                         |    4 ++--
 docs/ref/middleware.txt                            |    2 +-
 docs/ref/request-response.txt                      |    6 +++---
 docs/ref/templates/builtins.txt                    |    2 +-
 docs/releases/1.0.txt                              |    2 +-
 docs/releases/1.1-beta-1.txt                       |    2 +-
 docs/releases/1.1.txt                              |    2 +-
 docs/topics/auth.txt                               |    2 +-
 docs/topics/conditional-view-processing.txt        |    2 +-
 docs/topics/email.txt                              |    2 +-
 docs/topics/forms/media.txt                        |    4 ++--
 docs/topics/http/middleware.txt                    |    2 +-
 docs/topics/http/urls.txt                          |    4 ++--
 docs/topics/install.txt                            |    6 +++---
 tests/modeltests/custom_columns/tests.py           |    4 ++--
 .../custom_columns_regress/models.py               |    4 ++--
 tests/regressiontests/file_storage/tests.py        |    2 +-
 django/contrib/gis/gdal/srs.py      				|    2 +-
 django/contrib/sessions/models.py   				|    2 +-
 django/core/handlers/base.py        				|    2 +-
 django/core/servers/fastcgi.py      				|    2 +-
 docs/howto/deployment/fastcgi.txt   				|    6 +++---
 docs/howto/deployment/modpython.txt 				|    2 +-
 36 files changed, 58 insertions(+), 58 deletions(-)

diff --git a/docs/howto/jython.txt b/docs/howto/jython.txt
index 673c936..1bf8d6c 100644

                on top of Jython.
 .. _`django-jython`: http://code.google.com/p/django-jython/
 To install it, follow the `installation instructions`_ detailed on the project
 website. Also, read the `database backends`_ documentation there.
+Web site. Also, read the `database backends`_ documentation there.
 .. _`installation instructions`: http://code.google.com/p/django-jython/wiki/Install
 .. _`database backends`: http://code.google.com/p/django-jython/wiki/DatabaseBackends

docs/internals/committers.txt

diff --git a/docs/internals/committers.txt b/docs/internals/committers.txt
index b0bb18b..42a2ba3 100644

                Journal-World`_ of Lawrence, Kansas, USA.
 `Wilson Miner`_
     Wilson's design-fu is what makes Django look so nice. He designed the
     website you're looking at right now, as well as Django's acclaimed admin
+    Web site you're looking at right now, as well as Django's acclaimed admin
     interface. Wilson is the designer for EveryBlock_.
     Wilson lives in San Francisco, USA.
-…
+               Joseph Kocherhans
 `Brian Rosner`_
     Brian is currently the tech lead at Eldarion_ managing and developing
     Django / Pinax_ based websites. He enjoys learning more about programming
+    Django / Pinax_ based Web sites. He enjoys learning more about programming
     languages and system architectures and contributing to open source
     projects. Brian is the host of the `Django Dose`_ podcasts.

docs/internals/svn.txt

diff --git a/docs/internals/svn.txt b/docs/internals/svn.txt
index c66e494..9efbe28 100644

                The Django source code repository uses `Subversion`_ to track changes
 to the code over time, so you'll need a copy of the Subversion client
 (a program called ``svn``) on your computer, and you'll want to
 familiarize yourself with the basics of how Subversion
 works. Subversion's web site offers downloads for various operating
+works. Subversion's Web site offers downloads for various operating
 systems, and `a free online book`_ is available to help you get up to
 speed with using Subversion.
-…
+               repository address instead. At the top level of the repository are two
 directories: ``django`` contains the full source code for all Django
 releases, while ``djangoproject.com`` contains the source code and
 templates for the `djangoproject.com <http://www.djangoproject.com/>`_
 web site. For trying out in-development Django code, or contributing
+Web site. For trying out in-development Django code, or contributing
 to Django, you'll always want to check out code from some location in
 the ``django`` directory.
-…
+               into three areas:
 .. _Subversion: http://subversion.tigris.org/
 .. _a free online book: http://svnbook.red-bean.com/
 .. _A friendly web-based interface for browsing the code: http://code.djangoproject.com/browser/
+.. _A friendly Web-based interface for browsing the code: http://code.djangoproject.com/browser/
 Working with Django's trunk

docs/intro/index.txt

diff --git a/docs/intro/index.txt b/docs/intro/index.txt
index 90ee627..bc61be7 100644

-              a
 Getting started
 ===============
 New to Django? Or to web development in general? Well, you came to the right
+New to Django? Or to Web development in general? Well, you came to the right
 place: read this material to quickly get up and running.
 .. toctree::

docs/intro/whatsnext.txt

diff --git a/docs/intro/whatsnext.txt b/docs/intro/whatsnext.txt
index fe385ff..00c1654 100644

                Django's main documentation is broken up into "chunks" designed to fill
 different needs:
     * The :doc:`introductory material </intro/index>` is designed for people new
       to Django -- or to web development in general. It doesn't cover anything
+      to Django -- or to Web development in general. It doesn't cover anything
       in depth, but instead gives a high-level overview of how developing in
       Django "feels".
-…
+               You can get a local copy of the HTML documentation following a few easy steps:
     * Django's documentation uses a system called Sphinx__ to convert from
       plain text to HTML. You'll need to install Sphinx by either downloading
       and installing the package from the Sphinx website, or by Python's
+      and installing the package from the Sphinx Web site, or by Python's
       ``easy_install``:
       .. code-block:: bash

docs/misc/api-stability.txt

diff --git a/docs/misc/api-stability.txt b/docs/misc/api-stability.txt
index 70e5221..456d84b 100644

                Contributed applications (``django.contrib``)
 While we'll make every effort to keep these APIs stable -- and have no plans to
 break any contrib apps -- this is an area that will have more flux between
 releases. As the web evolves, Django must evolve with it.
+releases. As the Web evolves, Django must evolve with it.
 However, any changes to contrib apps will come with an important guarantee:
 we'll make sure it's always possible to use an older version of a contrib app if

docs/ref/contrib/gis/deployment.txt

diff --git a/docs/ref/contrib/gis/deployment.txt b/docs/ref/contrib/gis/deployment.txt
index fa7fe69..9100ff8 100644

                Deploying GeoDjango
     not thread safe at this time.  Thus, it is *highly* recommended
     to not use threading when deploying -- in other words, use a
     an appropriate configuration of Apache or the prefork method
     when using FastCGI through another web server.
+    when using FastCGI through another Web server.
 Apache
 ======

docs/ref/contrib/gis/index.txt

diff --git a/docs/ref/contrib/gis/index.txt b/docs/ref/contrib/gis/index.txt
index 074fa3a..c4959e0 100644

                GeoDjango
 .. module:: django.contrib.gis
    :synopsis: Geographic Information System (GIS) extensions for Django
 GeoDjango intends to be a world-class geographic web framework. Its goal is to
 make it as easy as possible to build GIS web applications and harness the power
+GeoDjango intends to be a world-class geographic Web framework. Its goal is to
+make it as easy as possible to build GIS Web applications and harness the power
 of spatially enabled data.
 .. toctree::

docs/ref/contrib/gis/install.txt

diff --git a/docs/ref/contrib/gis/install.txt b/docs/ref/contrib/gis/install.txt
index ae36e16..f4ae574 100644

                internal geometry representation used by GeoDjango (it's behind the "lazy"
 geometries).  Specifically, the C API library is called (e.g., ``libgeos_c.so``)
 directly from Python using ctypes.
 First, download GEOS 3.2 from the refractions website and untar the source
+First, download GEOS 3.2 from the refractions Web site and untar the source
 archive::
     $ wget http://download.osgeo.org/geos/geos-3.2.2.tar.bz2
-…
+               Windows XP
 Python
 ^^^^^^
 First, download the `Python 2.6 installer`__ from the Python website.  Next,
+First, download the `Python 2.6 installer`__ from the Python Web site.  Next,
 execute the installer and use defaults, e.g., keep 'Install for all users'
 checked and the installation path set as ``C:\Python26``.
-…
+               PostgreSQL
 ^^^^^^^^^^
 First, select a mirror and download the latest `PostgreSQL 8.3 installer`__ from
 the EnterpriseDB website.
+the EnterpriseDB Web site.
 .. note::

docs/ref/contrib/gis/model-api.txt

diff --git a/docs/ref/contrib/gis/model-api.txt b/docs/ref/contrib/gis/model-api.txt
index cf73747..b6d92dd 100644

                corresponds to the projection system that will be used to interpret the data
 in the spatial database. [#fnsrid]_  Projection systems give the context to the
 coordinates that specify a location.  Although the details of `geodesy`__ are
 beyond the scope of this documentation, the general problem is that the earth
 is spherical and representations of the earth (e.g., paper maps, web maps)
+is spherical and representations of the earth (e.g., paper maps, Web maps)
 are not.
 Most people are familiar with using latitude and longitude to reference a
-…
+               Additional Resources:
 * `spatialreference.org`__: A Django-powered database of spatial reference
   systems.
 * `The State Plane Coordinate System`__: A website covering the various
+* `The State Plane Coordinate System`__: A Web site covering the various
   projection systems used in the United States.  Much of the U.S. spatial
   data encountered will be in one of these coordinate systems rather than
   in a geographic coordinate system such as WGS84.

docs/ref/contrib/gis/tutorial.txt

diff --git a/docs/ref/contrib/gis/tutorial.txt b/docs/ref/contrib/gis/tutorial.txt
index 3a56c2e..69c60de 100644

                Introduction
 ============
 GeoDjango is an add-on for Django that turns it into a world-class geographic
 web framework.  GeoDjango strives to make at as simple as possible to create
 geographic web applications, like location-based services.  Some features include:
+Web framework.  GeoDjango strives to make at as simple as possible to create
+geographic Web applications, like location-based services.  Some features include:
 * Django model fields for `OGC`_ geometries.
 * Extensions to Django's ORM for the querying and manipulation of spatial data.
-…
+               yourself with basic Django concepts.
     for more details.
 This tutorial is going to guide you through guide the user through the creation
 of a geographic web application for viewing the `world borders`_. [#]_  Some of
+of a geographic Web application for viewing the `world borders`_. [#]_  Some of
 the code used in this tutorial is taken from and/or inspired by the
 `GeoDjango basic apps`_ project. [#]_
-…
+               as well as detailed information for each attribute field.  For example,
 ``FIPS: String (2.0)`` indicates that there's a ``FIPS`` character field
 with a maximum length of 2; similarly, ``LON: Real (8.3)`` is a floating-point
 field that holds a maximum of 8 digits up to three decimal places.  Although
 this information may be found right on the `world borders`_ website, this shows
+this information may be found right on the `world borders`_ Web site, this shows
 you how to determine this information yourself when such metadata is not
 provided.

docs/ref/contrib/gis/utils.txt

diff --git a/docs/ref/contrib/gis/utils.txt b/docs/ref/contrib/gis/utils.txt
index 8b14802..9f8e518 100644

                GeoDjango Utilities
    :synopsis: GeoDjango's collection of utilities.
 The :mod:`django.contrib.gis.utils` module contains various utilities that are
 useful in creating geospatial web applications.
+useful in creating geospatial Web applications.
 .. toctree::
    :maxdepth: 2

docs/ref/contrib/sites.txt

diff --git a/docs/ref/contrib/sites.txt b/docs/ref/contrib/sites.txt
index 7ff05a5..0a51025 100644

                The "sites" framework
 =====================
 .. module:: django.contrib.sites
    :synopsis: Lets you operate multiple web sites from the same database and
+   :synopsis: Lets you operate multiple Web sites from the same database and
               Django project
 Django comes with an optional "sites" framework. It's a hook for associating

docs/ref/forms/widgets.txt

diff --git a/docs/ref/forms/widgets.txt b/docs/ref/forms/widgets.txt
index 05215d4..37c1210 100644

                Customizing widget instances
 When Django renders a widget as HTML, it only renders the bare minimum
 HTML - Django doesn't add a class definition, or any other widget-specific
 attributes. This means that all 'TextInput' widgets will appear the same
 on your web page.
+on your Web page.
 If you want to make one widget look different to another, you need to
 specify additional attributes for each widget. When you specify a
-…
+               each widget will be rendered exactly the same::
     <tr><th>Comment:</th><td><input type="text" name="comment" /></td></tr>
 On a real web page, you probably don't want every widget to look the same. You
+On a real Web page, you probably don't want every widget to look the same. You
 might want a larger input element for the comment, and you might want the 'name'
 widget to have some special CSS class. To do this, you use the ``attrs``
 argument when creating the widget:

docs/ref/middleware.txt

diff --git a/docs/ref/middleware.txt b/docs/ref/middleware.txt
index 290ea27..de2a99f 100644

                Transaction middleware
 ----------------------
 .. module:: django.middleware.transaction
    :synopsis: Middleware binding a database transaction to each web request.
+   :synopsis: Middleware binding a database transaction to each Web request.
 .. class:: django.middleware.transaction.TransactionMiddleware

docs/ref/request-response.txt

diff --git a/docs/ref/request-response.txt b/docs/ref/request-response.txt
index b8b0882..8d2ce12 100644

                All attributes except ``session`` should be considered read-only.
 .. attribute:: HttpRequest.path_info
     Under some web server configurations, the portion of the URL after the host
+    Under some Web server configurations, the portion of the URL after the host
     name is split up into a script prefix portion and a path info portion
     (this happens, for example, when using the ``django.root`` option
     with the :ref:`modpython handler from Apache <howto-deployment-modpython>`).
     The ``path_info`` attribute always contains the path info portion of the
     path, no matter what web server is being used. Using this instead of
+    path, no matter what Web server is being used. Using this instead of
     attr:`~HttpRequest.path` can make your code much easier to move between test
     and deployment servers.
-…
+               All attributes except ``session`` should be considered read-only.
         * ``QUERY_STRING`` -- The query string, as a single (unparsed) string.
         * ``REMOTE_ADDR`` -- The IP address of the client.
         * ``REMOTE_HOST`` -- The hostname of the client.
         * ``REMOTE_USER`` -- The user authenticated by the web server, if any.
+        * ``REMOTE_USER`` -- The user authenticated by the Web server, if any.
         * ``REQUEST_METHOD`` -- A string such as ``"GET"`` or ``"POST"``.
         * ``SERVER_NAME`` -- The hostname of the server.
         * ``SERVER_PORT`` -- The port of the server.

docs/ref/templates/builtins.txt

diff --git a/docs/ref/templates/builtins.txt b/docs/ref/templates/builtins.txt
index 85c0b6d..8b242eb 100644

                See the :doc:`markup documentation </ref/contrib/markup>`.
 django.contrib.webdesign
 ~~~~~~~~~~~~~~~~~~~~~~~~
 A collection of template tags that can be useful while designing a website,
+A collection of template tags that can be useful while designing a Web site,
 such as a generator of Lorem Ipsum text. See :doc:`/ref/contrib/webdesign`.
 i18n

docs/releases/1.0.txt

diff --git a/docs/releases/1.0.txt b/docs/releases/1.0.txt
index 359490a..a2b6083 100644

                Welcome to Django 1.0!
 We've been looking forward to this moment for over three years, and it's finally
 here. Django 1.0 represents a the largest milestone in Django's development to
 date: a web framework that a group of perfectionists can truly be proud of.
+date: a Web framework that a group of perfectionists can truly be proud of.
 Django 1.0 represents over three years of community development as an Open
 Source project. Django's received contributions from hundreds of developers,

docs/releases/1.1-beta-1.txt

diff --git a/docs/releases/1.1-beta-1.txt b/docs/releases/1.1-beta-1.txt
index 8342396..535f818 100644

                release, including:
       notably, the memcached backend -- these operations will be atomic, and
       quite fast.
     * Django now can :doc:`easily delegate authentication to the web server
+    * Django now can :doc:`easily delegate authentication to the Web server
       </howto/auth-remote-user>` via a new authentication backend that supports
       the standard ``REMOTE_USER`` environment variable used for this purpose.

docs/releases/1.1.txt

diff --git a/docs/releases/1.1.txt b/docs/releases/1.1.txt
index 39cb0ab..3ca8344 100644

                Other new features and changes introduced since Django 1.0 include:
   notably, the memcached backend -- these operations will be atomic, and
   quite fast.
 * Django now can :doc:`easily delegate authentication to the web server
+* Django now can :doc:`easily delegate authentication to the Web server
   </howto/auth-remote-user>` via a new authentication backend that supports
   the standard ``REMOTE_USER`` environment variable used for this purpose.

docs/topics/auth.txt

diff --git a/docs/topics/auth.txt b/docs/topics/auth.txt
index 8c9b0f1..e0856e8 100644

                How to log a user out
     When you call :func:`~django.contrib.auth.logout()`, the session data for
     the current request is completely cleaned out. All existing data is
     removed. This is to prevent another person from using the same web browser
+    removed. This is to prevent another person from using the same Web browser
     to log in and have access to the previous user's session data. If you want
     to put anything into the session that will be available to the user
     immediately after logging out, do that *after* calling

docs/topics/conditional-view-processing.txt

diff --git a/docs/topics/conditional-view-processing.txt b/docs/topics/conditional-view-processing.txt
index b5da140..c631a13 100644

                Conditional View Processing
 HTTP clients can send a number of headers to tell the server about copies of a
 resource that they have already seen. This is commonly used when retrieving a
 web page (using an HTTP ``GET`` request) to avoid sending all the data for
+Web page (using an HTTP ``GET`` request) to avoid sending all the data for
 something the client has already retrieved. However, the same headers can be
 used for all HTTP methods (``POST``, ``PUT``, ``DELETE``, etc).

docs/topics/email.txt

diff --git a/docs/topics/email.txt b/docs/topics/email.txt
index 31092b0..33564b6 100644

                Testing e-mail sending
 ======================
 There are times when you do not want Django to send e-mails at
 all. For example, while developing a website, you probably don't want
+all. For example, while developing a Web site, you probably don't want
 to send out thousands of e-mails -- but you may want to validate that
 e-mails will be sent to the right people under the right conditions,
 and that those e-mails will contain the correct content.

docs/topics/forms/media.txt

diff --git a/docs/topics/forms/media.txt b/docs/topics/forms/media.txt
index 64cf507..548095d 100644

-              a
 Form Media
 ==========
 Rendering an attractive and easy-to-use web form requires more than just
+Rendering an attractive and easy-to-use Web form requires more than just
 HTML - it also requires CSS stylesheets, and if you want to use fancy
 "Web2.0" widgets, you may also need to include some JavaScript on each
 page. The exact combination of CSS and JavaScript that is required for
-…
+               you can define a custom Calendar widget. This widget can then be associated
 with the CSS and JavaScript that is required to render the calendar. When
 the Calendar widget is used on a form, Django is able to identify the CSS and
 JavaScript files that are required, and provide the list of file names
 in a form suitable for easy inclusion on your web page.
+in a form suitable for easy inclusion on your Web page.
 .. admonition:: Media and Django Admin

docs/topics/http/middleware.txt

diff --git a/docs/topics/http/middleware.txt b/docs/topics/http/middleware.txt
index eee398a..24d2a8e 100644

                of caveats:
       define ``__init__`` as requiring any arguments.
     * Unlike the ``process_*`` methods which get called once per request,
       ``__init__`` gets called only *once*, when the web server starts up.
+      ``__init__`` gets called only *once*, when the Web server starts up.
 Marking middleware as unused
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~

docs/topics/http/urls.txt

diff --git a/docs/topics/http/urls.txt b/docs/topics/http/urls.txt
index 1f49990..25f18ab 100644

                Normally, you should always use :func:`~django.core.urlresolvers.reverse` or
 :func:`~django.db.models.permalink` to define URLs within your application.
 However, if your application constructs part of the URL hierarchy itself, you
 may occasionally need to generate URLs. In that case, you need to be able to
 find the base URL of the Django project within its web server
+find the base URL of the Django project within its Web server
 (normally, :func:`~django.core.urlresolvers.reverse` takes care of this for
 you). In that case, you can call ``get_script_prefix()``, which will return the
 script prefix portion of the URL for your Django project. If your Django
 project is at the root of its webserver, this is always ``"/"``, but it can be
+project is at the root of its Web server, this is always ``"/"``, but it can be
 changed, for instance  by using ``django.root`` (see :ref:`How to use
 Django with Apache and mod_python <howto-deployment-modpython>`).

docs/topics/install.txt

diff --git a/docs/topics/install.txt b/docs/topics/install.txt
index 2965c32..782f627 100644

                Install Apache and mod_wsgi
 =============================
 If you just want to experiment with Django, skip ahead to the next
 section; Django includes a lightweight web server you can use for
+section; Django includes a lightweight Web server you can use for
 testing, so you won't need to set up Apache until you're ready to
 deploy Django in production.
-…
+               memory when the server starts. Code stays in memory throughout the
 life of an Apache process, which leads to significant performance
 gains over other server arrangements. In daemon mode, mod_wsgi spawns
 an independent daemon process that handles requests. The daemon
 process can run as a different user than the webserver, possibly
+process can run as a different user than the Web server, possibly
 leading to improved security, and the daemon process can be restarted
 without restarting the entire Apache webserver, possibly making
+without restarting the entire Apache Web server, possibly making
 refreshing your codebase more seamless. Consult the mod_wsgi
 documentation to determine which mode is right for your setup. Make
 sure you have Apache installed, with the mod_wsgi module activated.

tests/modeltests/custom_columns/tests.py

diff --git a/tests/modeltests/custom_columns/tests.py b/tests/modeltests/custom_columns/tests.py
index e8ec21f..f38f087 100644

                class CustomColumnsTests(TestCase):
         a1 = Author.objects.create(first_name="John", last_name="Smith")
         a2 = Author.objects.create(first_name="Peter", last_name="Jones")
         art = Article.objects.create(headline="Django lets you build web apps easily")
+        art = Article.objects.create(headline="Django lets you build Web apps easily")
         art.authors = [a1, a2]
         # Although the table and column names on Author have been set to custom
-…
+               class CustomColumnsTests(TestCase):
         # Get the articles for an author
         self.assertQuerysetEqual(
             a.article_set.all(), [
                 "Django lets you build web apps easily",
+                "Django lets you build Web apps easily",
             ],
             lambda a: a.headline
+        )

tests/regressiontests/custom_columns_regress/models.py

diff --git a/tests/regressiontests/custom_columns_regress/models.py b/tests/regressiontests/custom_columns_regress/models.py
index c55daf2..728f41f 100644

                __test__ = {'API_TESTS':"""
 >>> a2.save()
 # Create an article
 >>> art = Article(headline='Django lets you build web apps easily', primary_author=a)
+>>> art = Article(headline='Django lets you build Web apps easily', primary_author=a)
 >>> art.save()
 >>> art.authors = [a, a2]
-…
+               AttributeError: 'Author' object has no attribute 'last'
 # Get the articles for an author
 >>> a.article_set.all()
 [<Article: Django lets you build web apps easily>]
+[<Article: Django lets you build Web apps easily>]
 # Query the authors across the m2m relation
 >>> art.authors.filter(last_name='Jones')

tests/regressiontests/file_storage/tests.py

diff --git a/tests/regressiontests/file_storage/tests.py b/tests/regressiontests/file_storage/tests.py
index d59fe9c..901f25e 100644

                class FileStorageTests(unittest.TestCase):
     def test_file_url(self):
         """
         File storage returns a url to access a given file from the web.
+        File storage returns a url to access a given file from the Web.
         """
         self.assertEqual(self.storage.url('test.file'),
             '%s%s' % (self.storage.base_url, 'test.file'))

django/contrib/gis/gdal/srs.py

-- 

diff --git a/django/contrib/gis/gdal/srs.py b/django/contrib/gis/gdal/srs.py
index 93bd841..95e71f1 100644

                from django.contrib.gis.gdal.prototypes import srs as capi
 #### Spatial Reference class. ####
 class SpatialReference(GDALBase):
     """
     A wrapper for the OGRSpatialReference object.  According to the GDAL website,
+    A wrapper for the OGRSpatialReference object.  According to the GDAL Web site,
     the SpatialReference object "provide[s] services to represent coordinate
     systems (projections and datums) and to transform between them."
     """

django/contrib/sessions/models.py

diff --git a/django/contrib/sessions/models.py b/django/contrib/sessions/models.py
index c3b72e6..4c76ddf 100644

                class Session(models.Model):
     For complete documentation on using Sessions in your code, consult
     the sessions documentation that is shipped with Django (also available
     on the Django website).
+    on the Django Web site).
     """
     session_key = models.CharField(_('session key'), max_length=40,
                                    primary_key=True)

django/core/handlers/base.py

diff --git a/django/core/handlers/base.py b/django/core/handlers/base.py
index b03c2fd..45f8445 100644

                def get_script_name(environ):
     # If Apache's mod_rewrite had a whack at the URL, Apache set either
     # SCRIPT_URL or REDIRECT_URL to the full resource URL before applying any
     # rewrites. Unfortunately not every webserver (lighttpd!) passes this
+    # rewrites. Unfortunately not every Web server (lighttpd!) passes this
     # information through all the time, so FORCE_SCRIPT_NAME, above, is still
     # needed.
     script_url = environ.get('SCRIPT_URL', u'')

django/core/servers/fastcgi.py

diff --git a/django/core/servers/fastcgi.py b/django/core/servers/fastcgi.py
index 607cdb4..da52064 100644

                Optional Fcgi settings: (setting=value)
 Examples:
   Run a "standard" fastcgi process on a file-descriptor
   (for webservers which spawn your processes for you)
+  (for Web servers which spawn your processes for you)
     $ manage.py runfcgi method=threaded
   Run a scgi server on a TCP host/port

docs/howto/deployment/fastcgi.txt

diff --git a/docs/howto/deployment/fastcgi.txt b/docs/howto/deployment/fastcgi.txt
index c2b8aa8..54611c3 100644

                to the Web server, which, in turn, passes it back to the client's Web browser.
 Like mod_wsgi, FastCGI allows code to stay in memory, allowing requests to be
 served with no startup time. While mod_wsgi can either be configured embedded
 in the Apache webserver process or as a separate daemon process, a FastCGI
+in the Apache Web server process or as a separate daemon process, a FastCGI
 process never runs inside the Web server process, always in a separate,
 persistent process.
-…
+               Forcing the URL prefix to a particular value
 ============================================
 Because many of these fastcgi-based solutions require rewriting the URL at
 some point inside the webserver, the path information that Django sees may not
+some point inside the Web server, the path information that Django sees may not
 resemble the original URL that was passed in. This is a problem if the Django
 application is being served from under a particular prefix and you want your
 URLs from the ``{% url %}`` tag to look like the prefix, rather than the
 rewritten version, which might contain, for example, ``mysite.fcgi``.
 Django makes a good attempt to work out what the real script name prefix
 should be. In particular, if the webserver sets the ``SCRIPT_URL`` (specific
+should be. In particular, if the Web server sets the ``SCRIPT_URL`` (specific
 to Apache's mod_rewrite), or ``REDIRECT_URL`` (set by a few servers, including
 Apache + mod_rewrite in some situations), Django will work out the original
 prefix automatically.

docs/howto/deployment/modpython.txt

diff --git a/docs/howto/deployment/modpython.txt b/docs/howto/deployment/modpython.txt
index a9b665f..9152f0f 100644

                project (or somewhere else) that contains something like the following:
     import os
     os.environ['PYTHON_EGG_CACHE'] = '/some/directory'
 Here, ``/some/directory`` is a directory that the Apache webserver process can
+Here, ``/some/directory`` is a directory that the Apache Web server process can
 write to. It will be used as the location for any unpacking of code the eggs
 need to do.

Download in other formats:

Original Format

Issues

Context Navigation

Ticket #11509: 11509.2.diff

Download in other formats: