Final v1 cleanup (#56)

Author: rustagir

source/connection-troubleshooting.txt

@@ -129,6 +129,7 @@ are in the correct format.
    must `percent encode <https://tools.ietf.org/html/rfc3986#section-2.1>`__ it:
 
    .. code-block:: none
+      :copyable: false
 
       : / ? # [ ] @
 

source/fundamentals/authentication.txt

@@ -40,11 +40,10 @@ in the options of your connection string or in a ``Credential`` struct.
 In this guide, the examples demonstrate how to configure
 authentication in a ``Credential`` struct.
 
-..
-  To learn more about the connection string options for authentication,
-  see the :manual:`Authentication Options
-  </reference/connection-string/#authentication-options>` section
-  of the Connection String URI Format guide in the Server manual.
+To learn more about the connection string options for authentication,
+see the :manual:`Authentication Options
+</reference/connection-string/#authentication-options>` section
+of the Connection String URI Format guide in the Server manual.
 
 .. _rust-auth-scram-mechanisms:
 

source/fundamentals/connections/connection-options.txt

@@ -225,7 +225,7 @@ connected to the server.
          a value of ``9`` specifies maximum compression.
        | To learn more about network compression, see the :ref:`rust-network-compression` guide.
 
-..
-  To see a full list of connection options, visit the :manual:`Connection String
-  Options section </reference/connection-string/#connection-string-options>` of the
-  Server manual entry on Connection Strings.
+To see a full list of connection options, visit the
+:manual:`Connection String Options section
+</reference/connection-string/#connection-string-options>` of the
+Server manual entry on Connection Strings.

source/fundamentals/enterprise-auth.txt

@@ -109,8 +109,8 @@ To learn more about the concepts in this guide, see the following documentation:
 - :manual:`MongoDB Server Support for LDAP Proxy Authentication
   </core/security-ldap/>` in the Server manual
 - :ref:`rust-connection-options` guide
-
-.. - :manual:`Connection Strings </reference/connection-string>`
+- :manual:`Connection Strings </reference/connection-string>` in the
+  Server manual
 
 API Documentation
 ~~~~~~~~~~~~~~~~~

source/fundamentals/performance.txt

@@ -13,38 +13,41 @@ Performance Considerations
 Overview
 --------
 
-In this guide, you can learn how to optimize performance of the {+driver-short+}.
-To connect to MongoDB, you must create a ``Client`` instance. Your ``Client``
-instance automatically handles most aspects of connection, such as discovering server topology, monitoring
-your connection, and maintaining an internal connection pool.
-This guide describes best practices to configure and use your ``Client`` instance.
+In this guide, you can learn how to optimize the performance of the
+{+driver-short+}. To connect to MongoDB, you must create a ``Client`` instance. Your ``Client``
+instance automatically handles most aspects of connection, such as
+discovering server topology, monitoring your connection, and maintaining
+an internal connection pool. This guide describes best practices for
+configuring and using your ``Client`` instance.
 
 .. _rust-performance-client-lifecycle:
 
 Client Lifecycle
 ----------------
 
 We recommend that you reuse your client across sessions and operations.
-You can use the same ``Client`` instance to perform multiple tasks, as the ``Client`` type is safe for concurrent use by multiple threads.
-Creating a new ``Client`` instance for each request results in slower performance.
+You can use the same ``Client`` instance to perform multiple tasks, as
+the ``Client`` type is safe for concurrent use by multiple threads.
+Creating a new ``Client`` instance for each request results in slower
+performance.
 
-The following code creates a method that accepts a pointer to an existing ``Client`` instance,
-which allows you to execute many requests by using same client:
+The following code creates a method that accepts a pointer to an
+existing ``Client`` instance, which allows you to perform many requests
+by using the same client:
 
 .. literalinclude:: /includes/fundamentals/code-snippets/performance.rs
    :language: rust
    :dedent:
-   :start-after: start-perf-client-faster
-   :end-before: end-perf-client-faster
 
 .. _rust-performance-parallelism:
 
 Parallelism
 -----------
 
-If you can run parallel data operations, you can optimize performance by running asynchronous, concurrent tasks.
-The following code uses the ``task`` module from the ``tokio`` crate to create separate, concurrent
-tasks for multiple data operations:
+If you can run parallel data operations, you can optimize performance by
+running asynchronous, concurrent tasks. The following code uses the
+``spawn()`` method from the ``tokio::task`` module to create separate,
+concurrent tasks to perform insert operations:
 
 .. literalinclude:: /includes/fundamentals/code-snippets/performance-parallel.rs
    :language: rust
@@ -55,28 +58,31 @@ tasks for multiple data operations:
 Runtime
 -------
 
-A ``Client`` instance is bound to the instance of the ``tokio`` or ``async-std`` runtime in which you created it.
-If you use a ``Client`` instance to perform operations on a different runtime, you might experience unexpected behavior or failures.
+A ``Client`` instance is bound to the instance of the ``tokio`` or
+``async-std`` runtime in which you created it. If you use a ``Client``
+instance to perform operations on a different runtime, you might
+experience unexpected behavior or failures.
 
-If you are using the ``test`` helper macro from the ``tokio`` or ``async_std`` crate to test your application,
-you might accidentally run operations on a different runtime than you intended.
-This is because these helper macros create a new runtime for each test.
-You can use one of the following strategies to avoid this issue:
+If use the ``test`` helper macro from the ``tokio`` or
+``async_std`` crate to test your application, you might accidentally run
+operations on a different runtime than intended. This is because these
+helper macros create a new runtime for each test. However, you can use
+one of the following strategies to avoid this issue:
 
 - Attach the runtime to the ``Client`` instance without using the ``test`` helper macros.
 - Create a new ``Client`` instance for every ``async`` test.
 
 This example follows the first strategy and creates a global runtime used only for testing.
-In the following code, the ``test_list_dbs()`` method uses a client that manually connects to this runtime
-to list databases in the deployment.
+In the following code, the ``test_list_dbs()`` method uses a client that
+manually connects to this runtime to list databases in the deployment:
 
 .. literalinclude:: /includes/fundamentals/code-snippets/performance-bundle-runtime.rs
    :language: rust
    :dedent:
 
-Implementing the second strategy,
-the following code creates a new ``Client`` instance for each test run with ``tokio::test``, 
-ensuring that there is no unintended interaction between runtimes:
+Implementing the second strategy, the following code creates a new
+``Client`` instance for each test run with ``tokio::test``,
+ensuring that there are no unintended interactions between runtimes:
 
 .. literalinclude:: /includes/fundamentals/code-snippets/performance-new-client.rs
    :language: rust
@@ -85,13 +91,15 @@ ensuring that there is no unintended interaction between runtimes:
 Additional Information
 ----------------------
 
-For more information about the concepts in this guide, see the following pages:
+For more information about connecting to MongoDB, see the
+:ref:`Connection Guide <rust-connect-to-mongodb-client>`.
 
-- :ref:`Connection Guide <rust-connect-to-mongodb-client>`
+.. TODO link to runtimes page
 
 API Documentation
 ~~~~~~~~~~~~~~~~~
 
 - `Client() <{+api+}/struct.Client.html>`__
-
-.. TODO link to Async page when done
+- `spawn() <https://docs.rs/tokio/latest/tokio/task/fn.spawn.html>`__ in
+  the ``tokio::task`` module
+- `tokio::runtime <https://docs.rs/tokio/latest/tokio/runtime/index.html>`__ module

source/fundamentals/run-command.txt

@@ -93,7 +93,7 @@ Response
 --------
 
 The ``run_command()`` method returns a ``Document`` instance that contains
-the response from the database after the command has been executed. Each
+the response from the database after the command runs. Each
 database command performs a different function, so the response content
 can vary across commands. However, every response contains a document
 with the following fields:

source/fundamentals/schema-validation.txt

@@ -100,7 +100,7 @@ Example
 This example creates a collection called ``survey_answers`` with the
 following validation specifications:
 
-- The ``validator()`` method recieves a JSON schema specifying that the
+- The ``validator()`` method receives a JSON schema specifying that the
   ``answer`` field in each document must have a value of ``"yes"`` or
   ``"no"``.
 - The ``validation_action()`` method specifies whether the driver raises an

source/includes/fundamentals/code-snippets/performance-parallel.rs

@@ -1,15 +1,15 @@
 let client = Client::with_uri_str("<connection string>").await?;
-let some_data = doc! { "title": "1984", "author": "George Orwell" };
+let data = doc! { "title": "1984", "author": "George Orwell" };
 
 for i in 0..5 {
     let client_ref = client.clone();
-    let somedata_ref = some_data.clone();
+    let data_ref = data.clone();
 
     task::spawn(async move {
         let collection = client_ref
             .database("items")
             .collection::<Document>(&format!("coll{}", i));
 
-        collection.insert_one(somedata_ref, None).await
+        collection.insert_one(data_ref, None).await
     });
 }

source/includes/fundamentals/code-snippets/performance.rs

@@ -1,15 +1,6 @@
+// ... Create a client earlier in your code
 
-// start-perf-client-slow
-async fn handle_request() -> Result<(), Box<dyn Error>> {
-    let client = Client::with_uri_str("<connection string>").await?;
-    // Do something with the client
+async fn make_request(client: &Client) -> Result<(), Box<dyn Error>> {
+    // Use the client to perform operations
     Ok(())
 }
-// end-perf-client-slow
-
-// start-perf-client-faster
-async fn handle_request(client: &Client) -> Result<(), Box<dyn Error>> {
-    // Do something with the client
-    Ok(())
-}
-// end-perf-client-faster

source/issues-and-help.txt

@@ -15,7 +15,7 @@ To learn more, refer to the `support channels
 Bugs / Feature Requests
 -----------------------
 
-If you think you've found a bug or want to request a new feature in the
+If you think you found a bug or want to request a new feature in the
 {+driver-short+}, please open a case in MongoDB's issue management tool,
 JIRA, by performing the following steps: