Docsp 16491 typos (#106)

biniona-mongodb · kyuan-mongodb · web-flow · commit 365fd2f539bc · 2021-06-17T15:41:33.000-04:00
Co-authored-by: kyuan-mongodb &lt;78768401+kyuan-mongodb@users.noreply.github.com&gt;
diff --git a/source/includes/figures/atlas_connection_copy_string.png b/source/includes/figures/atlas_connection_copy_string.png
diff --git a/source/includes/quick-start/atlas-setup.rst b/source/includes/quick-start/atlas-setup.rst
@@ -4,7 +4,7 @@ Set up a Free Tier Cluster in Atlas
 After setting up your Java project dependencies, create a MongoDB cluster
 where you can store and manage your data. Complete the
 :atlas:`Get Started with Atlas </getting-started>` guide to set up a new
-Atlas account, free tier MongoDB cluster, load datasets, and
+Atlas account, create and launch a free tier MongoDB cluster, load datasets, and
 interact with the data.
 
 After completing the steps in the Atlas guide, you should have a new MongoDB
@@ -14,11 +14,11 @@ into your cluster.
 Connect to your Cluster
 -----------------------
 
-In this step, we create and run an application that uses the Java MongoDB
+In this step, we create and run an application that uses the MongoDB Java
 driver to connect to your MongoDB cluster and run a query on the sample
 data.
 
-We pass instructions to the driver on where and how to connect to your
+We pass instructions to the driver on how to connect to your
 MongoDB cluster in a string called the *connection string*. This string
 includes information on the hostname or IP address and port of your
 cluster, authentication mechanism, user credentials when applicable, and
@@ -33,8 +33,9 @@ want to connect to as shown below.
    :alt: Atlas Connection GUI cluster selection screen
 
 Proceed to the **Connect Your Application** step and select the Java driver.
-Then, select the "Connection String Only" tab and click the **Copy**
-button to copy the *connection string* to your clipboard as shown below.
+Select "4.1 or Later" for the version.
+Click the **Copy** icon to copy the *connection string* to your clipboard as
+shown below.
 
 .. figure:: /includes/figures/atlas_connection_copy_string.png
    :alt: Atlas Connection GUI connection string screen
diff --git a/source/includes/quick-start/pojo-query-output.rst b/source/includes/quick-start/pojo-query-output.rst
@@ -1,5 +1,5 @@
 When you run the ``QuickStartPojoExample`` class, it should output the details of the
-movie from the sample dataset which will look something like this:
+movie from the sample dataset which should look something like this:
 
 .. code-block:: none
 
diff --git a/source/includes/usage-examples/code-snippets/ReplaceOne.java b/source/includes/usage-examples/code-snippets/ReplaceOne.java
@@ -1,4 +1,3 @@
-// ignored first line
 package usage.examples;
 
 import static com.mongodb.client.model.Filters.eq;
diff --git a/source/includes/usage-examples/code-snippets/UpdateMany.java b/source/includes/usage-examples/code-snippets/UpdateMany.java
@@ -1,4 +1,3 @@
-// ignored first line
 package usage.examples;
 
 import static com.mongodb.client.model.Filters.gt;
diff --git a/source/usage-examples.txt b/source/usage-examples.txt
@@ -27,15 +27,15 @@ Overview
 --------
 
 Usage examples provide convenient starting points for popular MongoDB
-operations. Each example provides:
+operations. Each example provides the following information:
 
-- an explanation of the operation in the example showing the
+- An explanation of the operation in the example showing the
   purpose and a sample use case for the method
 
-- an explanation of how to use the operation, including parameters,
+- An explanation of how to use the operation, including parameters,
   return values, and common exceptions you might encounter
 
-- a full Java class that you can copy and paste to run the example
+- A full Java class that you can copy and paste to run the example
   in your own environment
 
 How to Use the Usage Examples
@@ -54,20 +54,20 @@ example into your development environment of choice. You can follow the
 :doc:`quick start guide </quick-start>` to learn more about getting
 started with the MongoDB Java driver. Once you've copied a usage example,
 you'll need to edit the connection string to get the example connected to
-your instance of MongoDB:
+your MongoDB instance:
 
 .. code-block:: java
 
    // Replace the following with your MongoDB deployment's connection string.
    String uri = "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&w=majority";
 
 You can use the :guides:`Atlas Connectivity Guide </cloud/connectionstring/>`
-to enable connectivity to your instance of Atlas and find the
-:manual:`connection string </reference/connection-string/>` to replace the
-``uri`` variable in the usage example. If your instance uses
+to learn how to allow connections to your instance of Atlas and to find the
+:manual:`connection string </reference/connection-string/>` you use to replace the
+``uri`` variable in usage examples. If your instance uses
 :manual:`SCRAM authentication </core/security-scram/>`, you can replace
 ``<user>`` with your username, ``<password>`` with your password, and
 ``<cluster-url>`` with the IP address or URL of your instance.
 
-For more information about connecting to your MongoDB instance, see the
-Connection Guide.
+For more information about connecting to your MongoDB instance, see our
+:doc:`Connection Guide </fundamentals/connection/>`.
diff --git a/source/usage-examples/bulkWrite.txt b/source/usage-examples/bulkWrite.txt
@@ -7,8 +7,8 @@ Perform Bulk Operations
 
 The ``bulkWrite()`` method performs batch write operations against a
 *single* collection. This method reduces the number of network round trips from
-your application to the server which therefore increases the potential 
-throughput and performance. Since you only receive the success status after 
+your application to your MongoDB instance which increases the performance of your
+application. Since you only receive the success status after 
 all the operations return, we recommend you use this if that meets the 
 requirements of your use case.
 
@@ -25,13 +25,13 @@ You can specify one or more of the following write operations in
 The ``bulkWrite()`` method accepts the following parameters:
 
 - A ``List`` of objects that implement ``WriteModel``: the classes that
-  implement the ``WriteModel`` correspond to the aforementioned write
+  implement ``WriteModel`` correspond to the aforementioned write
   operations. E.g. the ``InsertOneModel`` class wraps the ``insertOne`` write 
   operation. See the links to the API documentation at the bottom of this page 
   for more information on each class.
   
 - ``BulkWriteOptions``: *optional* object that specifies settings such as
-  whether to ensure the writes are ordered.
+  whether to ensure your MongoDB instance orders your write operations.
 
 .. note::
 
@@ -46,9 +46,9 @@ The ``bulkWrite()`` method accepts the following parameters:
   an error occurs during the processing of an operation, MongoDB returns
   without processing the remaining operations in the list. In contrast,
   when you set ``ordered`` to ``false``, MongoDB continues to process remaining
-  write operations in the list. Unordered operations are theoretically faster
-  since MongoDB can execute them in parallel, but should only be used if
-  the writes do not depend on order.
+  write operations in the list in the event of an error. Unordered operations
+  are theoretically faster since MongoDB can execute them in parallel, but
+  you should only use them if your writes do not depend on order.
 
 The ``bulkWrite()`` method returns a ``BulkWriteResult`` object that
 contains information about the write operation results including the number
diff --git a/source/usage-examples/command.txt b/source/usage-examples/command.txt
@@ -9,7 +9,7 @@ You can run all raw database operations using the
 command you can execute directly on the MongoDB server CLI. These
 commands include administrative and diagnostic tasks, such as fetching
 server stats or initializing a replica set. Call the ``runCommand()``
-method with a Bson command object on an instance of a ``MongoDatabase``
+method with a ``Bson`` command object on an instance of a ``MongoDatabase``
 to run your raw database operation.
 
 .. note::
@@ -18,7 +18,7 @@ to run your raw database operation.
     since these tasks are often quicker and easier to implement with the
     shell than in a Java application.
 
-The ``runCommand()`` method accepts a command in Bson format.
+The ``runCommand()`` method accepts a command in the form of a ``Bson`` object.
 By default, ``runCommand`` returns an object of type
 ``org.bson.Document`` containing the output of the database command. You
 can specify a return type for ``runCommand()`` as an optional second
diff --git a/source/usage-examples/count.txt b/source/usage-examples/count.txt
@@ -15,7 +15,7 @@ call to count the number of documents in a collection:
   documents in the collection based on the collection metadata. You cannot
   specify a query when using this method.
 
-The ``estimatedDocumentCount()`` method returns more quickly than
+The ``estimatedDocumentCount()`` method returns more quickly than the
 ``countDocuments()`` method because it uses the collection's metadata rather
 than scanning the entire collection. The ``countDocuments()`` method returns
 an **accurate** count of the number of documents and supports specifying
@@ -34,7 +34,7 @@ specify the behavior of the call:
    :widths: 17 20 10
 
    * - Method
-     - Optional Paramter Class
+     - Optional Parameter Class
      - Description
 
    * - ``countDocuments()``
diff --git a/source/usage-examples/deleteMany.txt b/source/usage-examples/deleteMany.txt
@@ -13,10 +13,10 @@ MongoDB matches all documents in the collection and deletes them. While
 you can use ``deleteMany()`` to delete all documents in a collection,
 consider using the ``drop()`` method instead for better performance.
 
-Upon successful delete, this method returns an instance of
+Upon successful deletion, this method returns an instance of
 ``DeleteResult``. You can retrieve information such as the number of
 documents deleted by calling the ``getDeletedCount()`` method on the
-``DeleteResult``.
+``DeleteResult`` instance.
 
 If your delete operation fails, the driver raises an exception. For more
 information on the types of exceptions raised under specific conditions,
diff --git a/source/usage-examples/deleteOne.txt b/source/usage-examples/deleteOne.txt
@@ -39,8 +39,8 @@ that looks something like this:
 
    Deleted document count: 1
 
-If your does query filter not match a document in your collection, no
-documents are removed and your call to ``deleteOne()`` returns the following:
+If your query filter does not match a document in your collection,
+your call to ``deleteOne()`` removes no documents and returns the following:
 
 .. code-block:: none
 
diff --git a/source/usage-examples/distinct.txt b/source/usage-examples/distinct.txt
@@ -21,8 +21,8 @@ value of the ``wins`` field in the ``awards`` embedded document:
 
    collection.distinct("awards.wins", Integer.class);
 
-You can optionally pass a query filter to the method document to limit
-the set of documents from which the distinct values are retrieved as
+You can optionally pass a query filter to the method to limit
+the set of documents from which your MongoDB instance retrieves distinct values as
 follows:
 
 .. code-block:: java
diff --git a/source/usage-examples/find.txt b/source/usage-examples/find.txt
@@ -38,7 +38,7 @@ returns ``false`` and therefore calling ``next()`` throws an exception.
 If you call ``next()`` on the iterator either after it has returned the final
 result or when no results exist, it throws an exception of type
 ``java.util.NoSuchElementException``. Always use ``hasNext()`` to check that
-additional results exist before every time you call ``next()``.
+additional results exist before you call ``next()``.
 
 
 Example
@@ -47,7 +47,7 @@ Example
 The following snippet finds and prints all documents that match a query on
 the ``movies`` collection. It uses the following objects and methods:
 
-- A **query filter** that is passed in the ``find()`` method. The ``lt()``
+- A **query filter** that is passed to the ``find()`` method. The ``lt()``
   filter matches only movies with a runtime of less than 15 minutes.
 
 - A **sort** that organizes returned documents in descending order by
diff --git a/source/usage-examples/findOne.txt b/source/usage-examples/findOne.txt
@@ -38,7 +38,7 @@ Example
 The following snippet finds a single document from the ``movies`` collection.
 It uses the following objects and methods:
 
-- A **query filter** that is passed in the ``find()`` method. The ``eq``
+- A **query filter** that is passed to the ``find()`` method. The ``eq``
   filter matches only movies with the title exactly matching the text
   ``'The Room'``.
 
diff --git a/source/usage-examples/insertMany.txt b/source/usage-examples/insertMany.txt
@@ -7,13 +7,13 @@ Insert Multiple Documents
 You can insert multiple documents into a collection in a single
 operation by calling the ``insertMany()`` method on a ``MongoCollection``
 object. To insert them, add your ``Document`` objects to a ``List`` and pass
-it to your call to ``insertMany()``. If you call the ``insertMany()`` method
+that ``List`` as an argument to ``insertMany()``. If you call the ``insertMany()`` method
 on a collection that does not exist yet, the server creates it for you.
 
-Upon successful insert, ``insertMany()`` returns an instance of
+Upon successful insertion, ``insertMany()`` returns an instance of
 ``InsertManyResult``. You can retrieve information such as the ``_id``
 fields of the documents you inserted by calling the ``getInsertedIds()``
-method on the ``InsertManyResult``.
+method on the ``InsertManyResult`` instance.
 
 If your insert operation fails, the driver raises an exception. For more
 information on the types of exceptions raised under specific conditions,
@@ -32,7 +32,7 @@ collection.
    :language: java
 
 When you run the example, you should see output that resembles the following
-with the inserted document ``ObjectId`` in each of the value fields:
+with the inserted documents' ``ObjectId`` values in each of the value fields:
 
 .. code-block:: none
 
diff --git a/source/usage-examples/insertOne.txt b/source/usage-examples/insertOne.txt
@@ -10,10 +10,10 @@ method on a ``MongoCollection`` object. To insert a document, construct a
 store. If you call the ``insertOne()`` method on a collection that does
 not exist yet, the server automatically creates it for you.
 
-Upon successful insert, ``insertOne()`` returns an instance of
+Upon a successful insertion, ``insertOne()`` returns an instance of
 ``InsertOneResult``. You can retrieve information such as the ``_id``
 field of the document you inserted by calling the ``getInsertedId()``
-method on the ``InsertOneResult``.
+method on the ``InsertOneResult`` instance.
 
 If your insert operation fails, the driver raises an exception. For more
 information on the types of exceptions raised under specific conditions,
@@ -32,7 +32,7 @@ collection.
    :language: java
 
 When you run the example, you should see output that resembles the following
-with the inserted document ``ObjectId`` in the value field:
+with the inserted document's ``ObjectId`` in the value field:
 
 .. code-block:: none
 
diff --git a/source/usage-examples/replaceOne.txt b/source/usage-examples/replaceOne.txt
@@ -12,10 +12,10 @@ with your replacement document.
 The ``replaceOne()`` method accepts a query filter that matches the
 document you want to replace and a replacement document that contains the
 data you want to save in place of the matched document. The ``replaceOne()``
-method only updates the first document that matches the filter.
+method only replaces the first document that matches the filter.
 
-You can optionally pass an instance of ``ReplaceOptions`` to the method in
-order to specify the method behavior. For example, if you set the ``upsert``
+You can optionally pass an instance of ``ReplaceOptions`` to the ``replaceOne()`` method in
+order to specify the method's behavior. For example, if you set the ``upsert``
 field of the ``ReplaceOptions`` object to ``true``, the operation inserts
 a new document from the fields in the replacement document if no documents
 match the query filter. See the link to the ``ReplaceOptions`` API
@@ -26,7 +26,7 @@ of ``UpdateResult``.  You can retrieve information such as the number of
 documents modified by calling the ``getModifiedCount()`` method. You can also
 retrieve the value of the document's ``_id`` field by calling the
 ``getUpsertedId()`` method if you set ``upsert(true)`` in the
-``UpdateOptions`` instance and the operation resulted in the insertion of a new document.
+``ReplaceOptions`` instance and the operation resulted in the insertion of a new document.
 
 If your replacement operation fails, the driver raises an exception.
 For example, if you try to specify a value for the immutable field
@@ -38,7 +38,7 @@ document, the method throws a ``MongoWriteException`` with the message:
    After applying the update, the (immutable) field '_id' was found to have been altered to _id: ObjectId('...)
 
 If your replacement document contains a change that violates unique index
-rules, the method throws a ``MongoWriteException`` with the error
+rules, the method throws a ``MongoWriteException`` with an error
 message that should look something like this:
 
 .. code-block:: none
@@ -64,7 +64,7 @@ document contains only the fields specified by the replacement document
 
 The following snippet uses the following objects and methods:
 
-- A **query filter** that is passed in the ``replaceOne()`` method. The ``eq``
+- A **query filter** that is passed to the ``replaceOne()`` method. The ``eq``
   filter matches only movies with the title exactly matching the text
   ``'Music of the Heart'``.
 
diff --git a/source/usage-examples/updateMany.txt b/source/usage-examples/updateMany.txt
@@ -1,46 +1,46 @@
-===========================
-Update a Multiple Documents
-===========================
+=========================
+Update Multiple Documents
+=========================
 
 .. default-domain:: mongodb
 
 You can update multiple documents using the ``updateMany()`` method on
 a ``MongoCollection`` object. The method accepts a **filter** that matches the
 document you want to update and an **update** statement that instructs the
-driver to change the matching document. The ``updateMany()`` method updates
+driver how to change the matching document. The ``updateMany()`` method updates
 all the documents in the collection that match the filter.
 
 To perform an update with the ``updateMany()`` method, you must pass
 a query filter and an update document. The query filter specifies which
 documents in the collection to match and the update document provides
 instructions on what changes to make to them.
 
-You can optionally pass an instance of ``UpdateOptions`` to the method in
+You can optionally pass an instance of ``UpdateOptions`` to the ``updateMany()`` method in
 order to modify the behavior of the call. For example, if you set the
 ``upsert`` field of the ``UpdateOptions`` object to ``true`` and no documents
 match the specified query filter, the operation inserts a new document
 composed of the fields from both the query and update document.
 
 Upon successful execution, the ``updateMany()`` method returns an instance
 of ``UpdateResult``. You can retrieve information such as the number of
-documents modified calling the ``getModifiedCount()`` method. If you
-specified ``upsert(true)`` in the ``UpdateOptions`` object and the
+documents modified by calling the ``getModifiedCount()`` method. If you
+specified ``upsert(true)`` in an ``UpdateOptions`` object and the
 operation results in an insert, you can retrieve the ``_id`` field of the
 new document by calling the ``getUpsertedId()`` method on the
-``UpdateResult``.
+``UpdateResult`` instance.
 
-If your update operation fails, the driver raises an exception and none of
-the documents matching the filter are updated. For example, if you try to set
-a value for the immutable field ``_id`` in your update document, no
-documents are updated and the method throws a ``MongoWriteException`` with the
-message:
+If your update operation fails, the driver raises an exception and does not update
+any of the documents matching the filter. For example, if you try to set
+a value for the immutable field ``_id`` in your update document, the
+``updateMany()`` method does not update any documents and throws a
+``MongoWriteException`` with the message:
 
 .. code-block:: none
 
    Performing an update on the path '_id' would modify the immutable field '_id'
 
 If your update document contains a change that violates unique index
-rules, the method throws a ``MongoWriteException`` with the error
+rules, the method throws a ``MongoWriteException`` with an error
 message that should look something like this:
 
 .. code-block:: none
@@ -54,9 +54,9 @@ bottom of this page.
 Example
 -------
 
-In this example, we update the first match for our query in the ``movies``
+In this example, we update documents that match our query in the ``movies``
 collection of the ``sample_mflix`` database. We perform the following
-updates to the matching document:
+updates to the matching documents:
 
 - Add ``Frequently Discussed`` to the array of ``genres`` only if it does not
   already exist
diff --git a/source/usage-examples/updateOne.txt b/source/usage-examples/updateOne.txt
diff --git a/source/usage-examples/watch.txt b/source/usage-examples/watch.txt

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,3 @@`
`1`		`-// ignored first line`
`2`	`1`	`package usage.examples;`
`3`	`2`
`4`	`3`	`import static com.mongodb.client.model.Filters.eq;`