Merge "Fix a wide variety of typos and broken links"

9 files changed, 21 insertions, 22 deletions

diff --git a/doc/build/core/connections.rst b/doc/build/core/connections.rst
index 6c100282e..976ac27e1 100644
--- a/doc/build/core/connections.rst
+++ b/doc/build/core/connections.rst
@@ -23,7 +23,7 @@ the :func:`_sa.create_engine` call::
 
     engine = create_engine('mysql://scott:tiger@localhost/test')
 
-The typical usage of :func:`_sa.create_engine()` is once per particular database
+The typical usage of :func:`_sa.create_engine` is once per particular database
 URL, held globally for the lifetime of a single application process. A single
 :class:`_engine.Engine` manages many individual :term:`DBAPI` connections on behalf of
 the process and is intended to be called upon in a concurrent fashion. The
@@ -492,7 +492,7 @@ The introduction on using :meth:`_engine.Connection.execute` made use of the
 :func:`_expression.text` construct in order to illustrate how textual SQL statements
 may be invoked.  When working with SQLAlchemy, textual SQL is actually more
 of the exception rather than the norm, as the Core expression language
-and the ORM both abstract away the textual representation of SQL.  Hpwever, the
+and the ORM both abstract away the textual representation of SQL.  However, the
 :func:`_expression.text` construct itself also provides some abstraction of textual
 SQL in that it normalizes how bound parameters are passed, as well as that
 it supports datatyping behavior for parameters and result set rows.
diff --git a/doc/build/core/constraints.rst b/doc/build/core/constraints.rst
index 4abe7709d..3e1eaabad 100644
--- a/doc/build/core/constraints.rst
+++ b/doc/build/core/constraints.rst
@@ -249,7 +249,7 @@ like the following is generated::
 .. versionchanged:: 1.0.0 - The DDL system invoked by
    :meth:`_schema.MetaData.create_all`
    and :meth:`_schema.MetaData.drop_all` will now automatically resolve mutually
-   depdendent foreign keys between tables declared by
+   dependent foreign keys between tables declared by
    :class:`_schema.ForeignKeyConstraint` and :class:`_schema.ForeignKey` objects, without
    the need to explicitly set the :paramref:`_schema.ForeignKeyConstraint.use_alter`
    flag.
diff --git a/doc/build/core/custom_types.rst b/doc/build/core/custom_types.rst
index 740d1593f..c9970872d 100644
--- a/doc/build/core/custom_types.rst
+++ b/doc/build/core/custom_types.rst
@@ -473,7 +473,7 @@ Redefining and Creating New Operators
 -------------------------------------
 
 SQLAlchemy Core defines a fixed set of expression operators available to all column expressions.
-Some of these operations have the effect of overloading Python's built in operators;
+Some of these operations have the effect of overloading Python's built-in operators;
 examples of such operators include
 :meth:`.ColumnOperators.__eq__` (``table.c.somecolumn == 'foo'``),
 :meth:`.ColumnOperators.__invert__` (``~table.c.flag``),
@@ -484,7 +484,7 @@ explicit methods on column expressions, such as
 
 The Core expression constructs in all cases consult the type of the expression in order to determine
 the behavior of existing operators, as well as to locate additional operators that aren't part of
-the built in set.   The :class:`.TypeEngine` base class defines a root "comparison" implementation
+the built-in set.   The :class:`.TypeEngine` base class defines a root "comparison" implementation
 :class:`.TypeEngine.Comparator`, and many specific types provide their own sub-implementations of this
 class.   User-defined :class:`.TypeEngine.Comparator` implementations can be built directly into a
 simple subclass of a particular type in order to override or define new operations.  Below,
diff --git a/doc/build/core/ddl.rst b/doc/build/core/ddl.rst
index f38dcf849..30619a419 100644
--- a/doc/build/core/ddl.rst
+++ b/doc/build/core/ddl.rst
@@ -140,7 +140,7 @@ provide DDL expressions. For example, to produce a ``CREATE TABLE`` statement:
 .. sourcecode:: python+sql
 
     from sqlalchemy.schema import CreateTable
-    with engine.connecT() as conn:
+    with engine.connect() as conn:
     {sql}    conn.execute(CreateTable(mytable))
     CREATE TABLE mytable (
         col1 INTEGER,
diff --git a/doc/build/core/defaults.rst b/doc/build/core/defaults.rst
index 6898324b6..3d6124b43 100644
--- a/doc/build/core/defaults.rst
+++ b/doc/build/core/defaults.rst
@@ -152,8 +152,8 @@ otherwise not provided, and the value will be that of whatever value is present
 in the execution for the ``counter`` column, plus the number 12.
 
 For a single statement that is being executed using "executemany" style, e.g.
-with multiple parameter sets passed to :meth:`_engine.Connection.execute`, the user-
-defined function is called once for each set of parameters. For the use case of
+with multiple parameter sets passed to :meth:`_engine.Connection.execute`, the
+user-defined function is called once for each set of parameters. For the use case of
 a multi-valued :class:`_expression.Insert` construct (e.g. with more than one VALUES
 clause set up via the :meth:`_expression.Insert.values` method), the user-defined function
 is also called once for each set of parameters.
@@ -242,8 +242,8 @@ all Python and SQL expressions which were pre-executed, are present in the
 :meth:`_engine.CursorResult.last_updated_params` collections on
 :class:`~sqlalchemy.engine.CursorResult`. The
 :attr:`_engine.CursorResult.inserted_primary_key` collection contains a list of primary
-key values for the row inserted (a list so that single-column and composite-
-column primary keys are represented in the same format).
+key values for the row inserted (a list so that single-column and
+composite-column primary keys are represented in the same format).
 
 .. _server_defaults:
 
@@ -371,7 +371,7 @@ Associating a Sequence on a SERIAL column
 PostgreSQL's SERIAL datatype is an auto-incrementing type that implies
 the implicit creation of a PostgreSQL sequence when CREATE TABLE is emitted.
 If a :class:`_schema.Column` specifies an explicit :class:`.Sequence` object
-which also specifies a true value for the :paramref:`.Sequence.optional`
+which also specifies a ``True`` value for the :paramref:`.Sequence.optional`
 boolean flag, the :class:`.Sequence` will not take effect under PostgreSQL,
 and the SERIAL datatype will proceed normally.   Instead, the :class:`.Sequence`
 will only take effect when used against other sequence-supporting
diff --git a/doc/build/core/internals.rst b/doc/build/core/internals.rst
index e5a710011..965c03fd9 100644
--- a/doc/build/core/internals.rst
+++ b/doc/build/core/internals.rst
@@ -5,7 +5,7 @@ Core Internals
 
 Some key internal constructs are listed here.
 
-.. currentmodule: sqlalchemy
+.. currentmodule:: sqlalchemy
 
 .. autoclass:: sqlalchemy.engine.interfaces.Compiled
     :members:
diff --git a/doc/build/core/sqlelement.rst b/doc/build/core/sqlelement.rst
index b7bb48b95..46cda7bf0 100644
--- a/doc/build/core/sqlelement.rst
+++ b/doc/build/core/sqlelement.rst
@@ -7,12 +7,12 @@ The expression API consists of a series of classes each of which represents a
 specific lexical element within a SQL string.  Composed together
 into a larger structure, they form a statement construct that may
 be *compiled* into a string representation that can be passed to a database.
-The classes are organized into a
-hierarchy that begins at the basemost ClauseElement class. Key subclasses
-include ColumnElement, which represents the role of any column-based expression
+The classes are organized into a hierarchy that begins at the basemost
+:class:`.ClauseElement` class. Key subclasses include :class:`.ColumnElement`,
+which represents the role of any column-based expression
 in a SQL statement, such as in the columns clause, WHERE clause, and ORDER BY
-clause, and FromClause, which represents the role of a token that is placed in
-the FROM clause of a SELECT statement.
+clause, and :class:`.FromClause`, which represents the role of a token that
+is placed in the FROM clause of a SELECT statement.
 
 .. autofunction:: all_
 
diff --git a/doc/build/core/tutorial.rst b/doc/build/core/tutorial.rst
index 90bdc8d9a..6d9ceb496 100644
--- a/doc/build/core/tutorial.rst
+++ b/doc/build/core/tutorial.rst
@@ -249,7 +249,7 @@ Executing
 The interesting part of an :class:`~sqlalchemy.sql.expression.Insert` is
 executing it.  This is performed using a database connection, which  is
 represented by the :class:`_engine.Connection` object.  To acquire a
-connection, we will use the :meth:`.Engine.connect` method::
+connection, we will use the :meth:`_engine.Engine.connect` method::
 
     >>> conn = engine.connect()
     >>> conn
@@ -956,8 +956,8 @@ Fetching the ``email_address`` column would be::
     >>> row._mapping[addresses.c.email_address]
     'jack@yahoo.com'
 
-If on the other hand we used a string column key, the usual rules of name-
-based matching still apply, and we'd get an ambiguous column error for
+If on the other hand we used a string column key, the usual rules of
+name-based matching still apply, and we'd get an ambiguous column error for
 the ``id`` value::
 
     >>> row._mapping["id"]
@@ -1215,7 +1215,7 @@ SELECT-oriented constructs which extend from :class:`_expression.SelectBase` may
 into aliased subqueries using the :meth:`_expression.SelectBase.subquery` method, which
 produces a :class:`.Subquery` construct; for ease of use, there is also a
 :meth:`_expression.SelectBase.alias` method that is synonymous with
-:class:`_expression.SelectBase.subquery`.   Like  :class:`_expression.Alias`, :class:`.Subquery` is
+:meth:`_expression.SelectBase.subquery`.   Like  :class:`_expression.Alias`, :class:`.Subquery` is
 also a :class:`_expression.FromClause` object that may be part of any enclosing SELECT
 using the same techniques one would use for a :class:`_expression.Alias`.
 
diff --git a/doc/build/core/type_api.rst b/doc/build/core/type_api.rst
index 115cbd202..0dd1b4920 100644
--- a/doc/build/core/type_api.rst
+++ b/doc/build/core/type_api.rst
@@ -20,5 +20,4 @@ Base Type API
 
 
 .. autoclass:: Variant
-
    :members: with_variant, __init__