DOCSP-21850 (#107)

* converted code-blocks to io-code-blocks

Author: jordan-smith721

source/fundamentals/bson.txt

@@ -237,22 +237,25 @@ The following example demonstrates how you can use the ``Decode()``
 method to unmarshal and read the result of a simple ``FindOne()``
 operation:
 
-.. code-block:: go
+.. io-code-block::
+   :copyable: true
 
-   coll := client.Database("school").Collection("students")
-   filter := bson.D{{"age", 8}}
+   .. input::
+      :language: go
 
-   var result bson.D
-   err := coll.FindOne(context.TODO(), filter).Decode(&result)
-   ...
+      coll := client.Database("school").Collection("students")
+      filter := bson.D{{"age", 8}}
 
-   fmt.Println(result)
+      var result bson.D
+      err := coll.FindOne(context.TODO(), filter).Decode(&result)
+      ...
 
-The output of the preceding code should look like this:
+      fmt.Println(result)
 
-.. code-block:: none
+   .. output::
+      :language: none
 
-   [{_id ObjectID("...")} {first_name Arthur} {street 1 Fern Way} {city Elwood City} {state PA} {age 8}]
+      [{_id ObjectID("...")} {first_name Arthur} {street 1 Fern Way} {city Elwood City} {state PA} {age 8}]
 
 The ``Cursor`` type also uses the ``All()`` method, which unmarshals all
 documents stored in the cursor into an array at the same time.
@@ -264,27 +267,30 @@ of ``[]byte`` type.
 The following code demonstrates how you can unmarshal BSON back into a
 user-defined struct by using methods from the ``bson`` package:
 
-.. code-block:: go
+.. io-code-block::
+   :copyable: true
 
-   type Item struct {
-      Category string
-      Quantity int32
-   }
-   ...
+   .. input::
+      :language: go
 
-   doc, err := bson.Marshal(bson.D{{"category", "plate"}, {"quantity", 6}})
-   ...
-   var test Item
-   err = bson.Unmarshal(doc, &test)
-   ...
-   fmt.Printf("Unmarshalled Struct:\n%+v\n", test)
+      type Item struct {
+         Category string
+         Quantity int32
+      }
+      ...
 
-The output of the preceding code should look like this:
+      doc, err := bson.Marshal(bson.D{{"category", "plate"}, {"quantity", 6}})
+      ...
+      var test Item
+      err = bson.Unmarshal(doc, &test)
+      ...
+      fmt.Printf("Unmarshalled Struct:\n%+v\n", test)
 
-.. code-block:: none
+   .. output::
+      :language: none
 
-   Unmarshalled Struct:
-   {Category:plate Quantity:6}
+      Unmarshalled Struct:
+      {Category:plate Quantity:6}
 
 .. note::
 

source/fundamentals/crud/compound-operations.txt

@@ -107,18 +107,26 @@ Example
 The following example matches and deletes a document where the ``type``
 is "Assam" with the ``FindOneAndDelete()`` method:
 
-.. literalinclude:: /includes/fundamentals/code-snippets/CRUD/compoundOperations.go
-   :language: go
-   :dedent:
-   :start-after: begin FindOneAndDelete
-   :end-before: end FindOneAndDelete
+.. io-code-block::
+   :copyable: true
+
+   .. input::
+      :language: go
+
+      filter := bson.D{{"type", "Assam"}}
 
-After running this example, the output resembles the following:
+      var deletedDoc bson.D
+      err := coll.FindOneAndDelete(context.TODO(), filter).Decode(&deletedDoc)
+      if err != nil {
+         panic(err)
+      }
 
-.. code-block:: none
-   :copyable: false
+      fmt.Println(deletedDoc)
 
-   [{_id ObjectID("...")} {type Assam} {rating 5}]
+   .. output::
+      :language: none
+
+      [{_id ObjectID("...")} {type Assam} {rating 5}]
 
 .. _golang-find-and-update:
 
@@ -201,18 +209,28 @@ The following example performs the following actions in order with the
 - Updates the matched document's ``rating`` to ``9``
 - Returns the updated document
 
-.. literalinclude:: /includes/fundamentals/code-snippets/CRUD/compoundOperations.go
-   :language: go
-   :dedent:
-   :start-after: begin FindOneAndUpdate
-   :end-before: end FindOneAndUpdate
+.. io-code-block::
+   :copyable: true
 
-After running this example, the output resembles the following:
+   .. input::
+      :language: go
 
-.. code-block:: none
-   :copyable: false
+      filter := bson.D{{"type", "Oolong"}}
+      update := bson.D{{"$set", bson.D{{"rating", 9}}}}
+      opts := options.FindOneAndUpdate().SetReturnDocument(options.After)
 
-   [{_id ObjectID("...")} {type Oolong} {rating 9}]
+      var updatedDoc bson.D
+      err := coll.FindOneAndUpdate(context.TODO(), filter, update, opts).Decode(&updatedDoc)
+      if err != nil {
+         panic(err)
+      }
+
+      fmt.Println(updatedDoc)
+
+   .. output::
+      :language: none
+
+      [{_id ObjectID("...")} {type Oolong} {rating 9}]
 
 .. _golang-find-and-replace:
 
@@ -290,18 +308,27 @@ The following example performs the following actions in order with the
 - Matches a document where the ``type`` is "English Breakfast"
 - Replaces the matched document with a new document where the ``type`` is "Ceylon" and  ``rating`` is ``6``
 
-.. literalinclude:: /includes/fundamentals/code-snippets/CRUD/compoundOperations.go
-   :language: go
-   :dedent:
-   :start-after: begin FindOneAndReplace
-   :end-before: end FindOneAndReplace
+.. io-code-block::
+   :copyable: true
+
+   .. input::
+      :language: go
+
+      filter := bson.D{{"type", "English Breakfast"}}
+      replacement := bson.D{{"type", "Ceylon"}, {"rating", 6}}
 
-After running this example, the output resembles the following:
+      var previousDoc bson.D
+      err := coll.FindOneAndReplace(context.TODO(), filter, replacement).Decode(&previousDoc)
+      if err != nil {
+         panic(err)
+      }
 
-.. code-block:: none
-   :copyable: false
+      fmt.Println(previousDoc)
+      
+   .. output::
+      :language: none
 
-   [{_id ObjectID("...")} {type English Breakfast} {rating 5}]
+      [{_id ObjectID("...")} {type English Breakfast} {rating 5}]
 
 Additional Information
 ----------------------

source/fundamentals/crud/read-operations/count.txt

@@ -92,18 +92,24 @@ Example
 The following example counts the number of documents where the
 ``rating`` is less than ``6``:
 
-.. literalinclude:: /includes/fundamentals/code-snippets/CRUD/countAndEstimate.go
-   :language: go
-   :dedent:
-   :start-after: begin count documents
-   :end-before: end count documents
+.. io-code-block::
+   :copyable: true
+
+   .. input::
+      :language: go
 
-After running this example, the output resembles the following:
+      filter := bson.D{{"rating", bson.D{{"$lt", 6}}}}
 
-.. code-block:: none
-   :copyable: false
+      count, err := coll.CountDocuments(context.TODO(), filter)
+      if err != nil {
+         panic(err)
+      }
+      fmt.Printf("Number of ratings less than six: %d\n", count)
 
-   Number of ratings less than six: 4
+   .. output::
+      :language: none
+
+      Number of ratings less than six: 4
 
 Aggregation
 -----------
@@ -119,18 +125,32 @@ The following example performs the following actions:
 - Counts the number of documents where the ``rating`` is greater than ``5``
 - Assigns the count to a field called ``total_documents``
 
-.. literalinclude:: /includes/fundamentals/code-snippets/CRUD/countAndEstimate.go
-   :language: go
-   :dedent:
-   :start-after: begin aggregate count
-   :end-before: end aggregate count
+.. io-code-block::
+   :copyable: true
 
-After running this example, the output resembles the following:
+   .. input::
+      :language: go
 
-.. code-block:: none
-   :copyable: false
+      matchStage := bson.D{{"$match", bson.D{{"rating", bson.D{{"$gt", 5}}}}}}
+      countStage := bson.D{{"$count", "total_documents"}}
 
-   [{total_documents 5}]
+      cursor, err := coll.Aggregate(context.TODO(), mongo.Pipeline{matchStage, countStage})
+      if err != nil {
+         panic(err)
+      }
+
+      var results []bson.D
+      if err = cursor.All(context.TODO(), &results); err != nil {
+         panic(err)
+      }
+      for _, result := range results {
+         fmt.Println(result)
+      }
+
+   .. output::
+      :language: none
+
+      [{total_documents 5}]
 
 .. _golang-estimated-count:
 
@@ -173,18 +193,22 @@ Example
 The following example estimates the number of documents in the
 ``ratings`` collection:
 
-.. literalinclude:: /includes/fundamentals/code-snippets/CRUD/countAndEstimate.go
-   :language: go
-   :dedent:
-   :start-after: begin est doc count
-   :end-before: end est doc count
+.. io-code-block::
+   :copyable: true
+
+   .. input::
+      :language: go
 
-After running this example, the output resembles the following:
+      count, err := coll.EstimatedDocumentCount(context.TODO())
+      if err != nil {
+         panic(err)
+      }
+      fmt.Printf("Estimated number of documents in the ratings collection: %d\n", count)
 
-.. code-block:: none
-   :copyable: false
+   .. output::
+      :language: none
 
-   Estimated number of documents in the ratings collection: 9
+      Estimated number of documents in the ratings collection: 9
 
 Additional Information
 ----------------------

source/fundamentals/crud/read-operations/distinct.txt

@@ -83,21 +83,28 @@ Example
 The following example matches all documents and prints the distinct values
 of the ``type`` field using the ``Distinct()`` method: 
 
-.. literalinclude:: /includes/fundamentals/code-snippets/CRUD/distinctValues.go
-   :language: go
-   :dedent:
-   :start-after: begin distinct
-   :end-before: end distinct
-
-After running this example, the output resembles the following:
-
-.. code-block:: none
-   :copyable: false
-   
-   Earl Grey
-   Masala
-   Matcha
-   Oolong
+.. io-code-block::
+   :copyable: true
+
+   .. input::
+      :language: go
+
+      results, err := coll.Distinct(context.TODO(), "type", bson.D{})
+      if err != nil {
+         panic(err)
+      }
+
+      for _, result := range results {
+         fmt.Println(result)
+      }
+
+   .. output::
+      :language: none
+
+      Earl Grey
+      Masala
+      Matcha
+      Oolong
 
 Additional Information
 ----------------------