Docs Site: Consistent use of apiref and backticks around the class/method names for the text of those references.

Author: jyemin

docs/reference/content/getting-started/quick-tour-admin.md

@@ -136,11 +136,11 @@ collection.insertOne(new Document("_id", 1).append("content", "additional conten
 collection.insertOne(new Document("_id", 2).append("content", "irrelevant content"));
 
 // Find using the text index
-long matchCount = collection.count(text("textual content -irrelevant"));
+long matchCount = collection.count(Filters.text("textual content -irrelevant"));
 System.out.println("Text search matches: " + matchCount);
 
 // Find using the $language operator
-Bson textSearch = text("textual content -irrelevant", "english");
+Bson textSearch = Filters.text("textual content -irrelevant", "english");
 matchCount = collection.count(textSearch);
 System.out.println("Text search matches (english): " + matchCount);
 
@@ -161,4 +161,7 @@ Highest scoring document: { "_id" : 1, "content" : "additional content", "score"
 For more information about text search see the [text index]({{< docsref "/core/index-text" >}}) and
 [$text query operator]({{< docsref "/reference/operator/query/text">}}) documentation.
 
-That concludes the admin quick tour overview!  Remember any [command]({{< docsref "/reference/command">}}) that doesn't have a specific helper can be called by the [database.runCommand()](http://api.mongodb.org/java/3.0/?com/mongodb/async/client/MongoDatabase.html#runCommand-org.bson.conversions.Bson-com.mongodb.ReadPreference-com.mongodb.async.SingleResultCallback-).
+That concludes the admin quick tour overview!  Remember any [command]({{< docsref "/reference/command">}}) that doesn't have a specific 
+helper can be called by the 
+[`runCommand()`]({{< apiref "com/mongodb/client/MongoDatabase.html#runCommand-org.bson.conversions.Bson-">}}) method on 
+`MongoDatabase`.

docs/reference/content/getting-started/quick-tour.md

@@ -72,7 +72,7 @@ When creating many `MongoClient` instances:
 ## Get a Collection
 
 To get a collection to operate upon, specify the name of the collection to
-the [getCollection(String collectionName)]({{< apiref "com/mongodb/client/MongoDatabase.html#getCollection-java.lang.String-">}})
+the [`getCollection()`]({{< apiref "com/mongodb/client/MongoDatabase.html#getCollection-java.lang.String-">}})
 method:
 
 The following example gets the collection `test`. If the collection does not
@@ -104,7 +104,7 @@ contains a field `info` which is an embedded document:
 ```
 
 To create the document using the Java driver, use the
-[Document]({{< apiref "org/bson/Document.html">}}) class. You
+[`Document`]({{< apiref "org/bson/Document.html">}}) class. You
 can use this class to create the embedded document as well.
 
 ```java
@@ -152,7 +152,7 @@ collection.insertMany(documents);
 
 Now that we've inserted 101 documents (the 100 we did in the loop, plus
 the first one), we can check to see if we have them all using the
-[count()]({{< apiref "com/mongodb/client/MongoCollection#count--">}})
+[`count()`]({{< apiref "com/mongodb/client/MongoCollection#count--">}})
 method. The following code should print `101`.
 
 ```java
@@ -162,16 +162,16 @@ System.out.println(collection.count());
 ## Query the Collection
 
 Use the
-[find()]({{< apiref "com/mongodb/client/MongoCollection.html#find--">}})
+[`find()`]({{< apiref "com/mongodb/client/MongoCollection.html#find--">}})
 method to query the collection.
 
 ### Find the First Document in a Collection
 
 call the first() method on the result of the find() of method
 
 To get the first document in the collection, call the
-[first()]({{< apiref "com/mongodb/client/MongoIterable.html#first--">}})
-method on the [find()]({{< apiref "com/mongodb/client/MongoCollection.html#find--">}})
+[`first()`]({{< apiref "com/mongodb/client/MongoIterable.html#first--">}})
+method on the [`find()`]({{< apiref "com/mongodb/client/MongoCollection.html#find--">}})
 operation. `collection.find().first()` returns the first document or null rather than a cursor.
 This is useful for queries that should only match a single document, or if you are
 interested in the first document only.
@@ -250,7 +250,8 @@ and it should just print just one document
 
 
 {{% note %}}
-Use the [Filters]({{< apiref "com/mongodb/client/model/Filters">}}), [Sorts]({{< apiref "com/mongodb/client/model/Sorts">}}) and [Projections]({{< apiref "com/mongodb/client/model/Projections">}})
+Use the [`Filters`]({{< apiref "com/mongodb/client/model/Filters">}}), [`Sorts`]({{< apiref "com/mongodb/client/model/Sorts">}}) and 
+[`Projections`]({{< apiref "com/mongodb/client/model/Projections">}})
 helpers for simple and concise ways of building up queries.
 {{% /note %}}
 
@@ -282,8 +283,9 @@ collection.find(and(gt("i", 50), lte("i", 100))).forEach(printBlock);
 
 ## Sorting documents
 
-We can also use the [Sorts]({{< apiref "com/mongodb/client/model/Sorts">}}) helpers to sort documents.
-We add a sort to a find query by calling the `sort()` method on a `FindIterable`.  Below we use the [`exists()`]({{ < apiref "com/mongodb/client/model/Filters.html#exists-java.lang.String-">}}) helper and sort
+We can also use the [`Sorts`]({{< apiref "com/mongodb/client/model/Sorts">}}) helpers to sort documents.
+We add a sort to a find query by calling the `sort()` method on a `FindIterable`.  Below we use the 
+[`exists()`]({{ < apiref "com/mongodb/client/model/Filters.html#exists-java.lang.String-">}}) helper and sort
 [`descending("i")`]({{ < apiref "com/mongodb/client/model/Sorts.html#exists-java.lang.String-">}}) helper to
 sort our documents:
 
@@ -294,7 +296,8 @@ System.out.println(myDoc.toJson());
 
 ## Projecting fields
 
-Sometimes we don't need all the data contained in a document, the [Projections]({{< apiref "com/mongodb/client/model/Projections">}}) helpers help build the projection parameter for the
+Sometimes we don't need all the data contained in a document, the [`Projections`]({{< apiref "com/mongodb/client/model/Projections">}}) 
+helpers help build the projection parameter for the
 find operation.  Below we'll sort the collection, exclude the `_id` field and output the first
 matching document:
 

docs/reference/content/reference/bson/documents.md

@@ -13,7 +13,7 @@ The driver includes several classes and interfaces used for representing BSON do
 
 ### BsonDocument
 
-Although generally not needed by users of the high-level driver API, the [BsonDocument]({{< apiref "org/bson/BsonDocument" >}}) class is 
+Although generally not needed by users of the high-level driver API, the [`BsonDocument`]({{< apiref "org/bson/BsonDocument" >}}) class is 
 central to the way that documents are managed internally by the driver.  The BsonDocument class can represent dynamically structured 
 documents of any complexity with a type-safe API.  For instance, the document `{ a: "MongoDB", b: [ { c: 1 } ] }` can be constructed as a
 BsonDocument as follows:
@@ -25,11 +25,11 @@ new BsonDocument().append("a", new BsonString("MongoDB"))
 
 The type safety comes from BsonDocument implementing `Map<String, BsonValue>`, so even built-in types like `int`, `String` and `List` must
 be wrapped in a sub-class of `BsonValue`.  For a complete list of BsonValue sub-types, please consult the 
-[API documentation]({{< apiref "org/bson/BsonValue" >}}). 
+[`BsonValue`]({{< apiref "org/bson/BsonValue" >}}) API documentation. 
 
 ### Document
 
-Most applications will use the [Document]({{< apiref "org/bson/Document" >}}) class instead.  Like BsonDocument, the 
+Most applications will use the [`Document`]({{< apiref "org/bson/Document" >}}) class instead.  Like BsonDocument, the 
 Document class can represent dynamically structured documents of any complexity; however, the typing is much looser, as Document 
 implements `Map<String, Object>`. As a result, the same document as above can be constructed using the Document class as follows:
 
@@ -60,7 +60,7 @@ It is actually possible to change these mappings; the mechanism for doing so is
 ### DBObject
 
 Although not recommended for new applications, those upgrading from the 2.x driver series may continue to use the 
-[DBObject]({{< apiref "com/mongodb/DBObject" >}}) interface to represent BSON documents.  DBObject is similar to Document in that it 
+[`DBObject`]({{< apiref "com/mongodb/DBObject" >}}) interface to represent BSON documents.  DBObject is similar to Document in that it 
 represents BSON values as `Object`, but it has a few shortcomings that were impossible to overcome:
 
 - it is an interface rather than a class, so it's API can not be extended without breaking binary compatibility
@@ -70,7 +70,7 @@ that interface, is required
 
 ### Bson
 
-To tie these all together, the driver contains a small but powerful interface called [Bson]({{< apiref "org/bson/conversions/Bson" >}}). 
+To tie these all together, the driver contains a small but powerful interface called [`Bson`]({{< apiref "org/bson/conversions/Bson" >}}). 
 Any class that represents a BSON document, whether included in the driver itself or from a third party, can implement this interface and 
 can then be used any place in the high-level API where a BSON document is required. The three classes discussed above all implement this 
 interface and so can be used interchangeably based on the needs of a given application.  For example:

docs/reference/content/reference/bson/extended-json.md

@@ -9,14 +9,14 @@ title = "Extended JSON"
 
 ## MongoDB Extended JSON
 
-The Java driver supports reading and writing JSON-like documents with the [JsonReader]({{< apiref "org/bson/json/JsonReader" >}}) and
-[JsonWriter]({{< apiref "org/bson/json/JsonWriter" >}}) classes, which can read/write both flavors of 
+The Java driver supports reading and writing JSON-like documents with the [`JsonReader`]({{< apiref "org/bson/json/JsonReader" >}}) and
+[`JsonWriter`]({{< apiref "org/bson/json/JsonWriter" >}}) classes, which can read/write both flavors of 
 [MongoDB Extended JSON](http://docs.mongodb.org/manual/reference/mongodb-extended-json/): 
 
-- MongoDB Extended JSON Strict Mode: representations of BSON types that conform to the [JSON RFC](http://www.json.org/). This is the 
+- Strict Mode: representations of BSON types that conform to the [JSON RFC](http://www.json.org/). This is the 
 format that [mongoexport](http://docs.mongodb.org/manual/reference/program/mongoexport/) produces and 
 [mongoimport](http://docs.mongodb.org/manual/reference/program/mongoimport/) consumes.
-- MongoDB Shell Mode: a superset of JSON that the 
+- Shell Mode: a superset of JSON that the 
 [MongoDB shell](http://docs.mongodb.org/manual/tutorial/getting-started-with-the-mongo-shell/) can parse. 
 
 

docs/reference/content/reference/bson/index.md

@@ -13,4 +13,4 @@ The driver comprehensively supports [BSON](http://www.bsonspec.org), the data st
 “documents". BSON, short for Binary [JSON](http://json.org/), is a binary-encoded serialization of JSON-like documents.
 
 - [Documents]({{< relref "documents.md" >}}): Documentation of the driver's support for BSON documents
-- [MongoDB Extended JSON]({{< relref "extended-json.md" >}}): Documentation of the driver's support for MongoDB Extended JSON
+- [Extended JSON]({{< relref "extended-json.md" >}}): Documentation of the driver's support for MongoDB Extended JSON

docs/reference/content/reference/connecting/authenticating.md

@@ -13,10 +13,13 @@ The Java driver supports all MongoDB [authentication mechanisms](http://docs.mon
 only available in the MongoDB [Enterprise Edition](http://docs.mongodb.org/manual/administration/install-enterprise/).
 
 An authentication credential is represented as an instance of the
-[MongoCredential](http://api.mongodb.org/java/current/com/mongodb/MongoCredential.html) class, which includes static factory methods for
+[`MongoCredential`]({{< apiref "com/mongodb/MongoCredential" >}}) class, which includes static factory methods for
 each of the supported authentication mechanisms.  A list of these instances must be passed to the driver via one of several
-[MongoClient](http://api.mongodb.org/java/current/com/mongodb/MongoCredential.html) constructors that take a
-parameter of type `List<MongoCredential>`.
+[`MongoClient`]({{< apiref "com/mongodb/MongoClient" >}}) constructors that take either a 
+parameter of type `List<MongoCredential>`.  Alternatively, a single [`MongoCredential`]({{< apiref "com/mongodb/MongoCredential" >}})
+can be created implicity via a 
+[`MongoClientURI`]({{< apiref "com/mongodb/MongoClientURI" >}}) and passed to a [`MongoClient`]({{< apiref "com/mongodb/MongoClient" >}})
+constructor that takes a `[`MongoClientURI`]({{< apiref "com/mongodb/MongoClientURI" >}}) parameter. 
 
 {{% note %}}
 Given the flexibility of role-based access control in MongoDB, it is usually sufficient to authenticate with a single user, but, for completeness, the driver accepts a list of credentials.

docs/reference/content/reference/connecting/index.md

@@ -44,12 +44,14 @@ mongodb://host:27017/mydb
 Above, the database by the name of "mydb" is where the credentials are stored for the application.
 
 {{% note %}}
-Some drivers utilize the database component to indicate which database to work with by default. The Java driver, while it parses the database component, does not use the database component for anything other than authentication.
+Some drivers utilize the database component to indicate which database to work with by default. The Java driver, while it parses the 
+database component, does not use the database component for anything other than authentication.
 {{% /note %}}
 
 #### Options
 
-Many options can be provided via the connection string. The ones that cannot may be provided in a `MongoClientOptions` instance. To
+Many options can be provided via the connection string. The ones that cannot may be provided in a 
+[`MongoClientOptions`]({{< apiref "com/mongodb/MongoClientOptions" >}}) instance. To
 provide an option, append a `?` to the connection string and separate options by an `&`.
 
 ```ini
@@ -58,15 +60,14 @@ mongodb://host:27017/?replicaSet=rs0&maxPoolSize=200
 
 The above connection string sets the "replicaSet" value to "rs0" and the "maxPoolSize" to "200".
 
-For a comprehensive list of the available options, see the [MongoClientURI](http://api.mongodb.org/java/3.0/com/mongodb/MongoClientURI.html)
-documentation.  
+For a comprehensive list of the available options, see the [`MongoClientURI`]({{< apiref "com/mongodb/MongoClientURI" >}}) documentation.  
 
 
 ### MongoClient
 
-A `MongoClient` instance will be the root object for all interaction with MongoDB. It is all that is needed to handle connecting to
-servers, monitoring servers, and performing operations against those servers. Without any arguments, constructing a `MongoClient`
-instance will connect to "localhost" port 27017.  
+A [`MongoClient`]({{< apiref "com/mongodb/MongoClient" >}}) instance will be the root object for all interaction with MongoDB. It is all 
+that is needed to handle connecting to servers, monitoring servers, and performing operations against those servers. Without any 
+arguments, constructing a [`MongoClient`]({{< apiref "com/mongodb/MongoClient" >}}) instance will connect to "localhost" port 27017.  
 
 ```java
 MongoClient client = new MongoClient();
@@ -78,16 +79,17 @@ Alternatively, a connection string may be provided:
 MongoClient client = new MongoClient(new MongoClientURI("mongodb://host:27017,host2:27017/?replicaSet=rs0"));
 ```
 
-Finally, the `MongoClientOptions` class provides an in-code way to set the same options from a connection string.  This is sometimes
+Finally, the [`MongoClientOptions`]({{< apiref "com/mongodb/MongoClientOptions" >}}) class provides an in-code way to set the same options from a connection string.  This is sometimes
 necessary, as the connection string does not allow an application to configure as many configuration options as `MongoClientOptions`.  
-`MongoClientOptions` instances are immutable, so to create one your application uses a builder:
+[`MongoClientOptions`]({{< apiref "com/mongodb/MongoClientOptions" >}}) instances are immutable, so to create one your application uses a builder:
 
 ```java
 MongoClientOptions options = MongoClientOptions.builder().cursorFinalizerEnabled(false).build();
 MongoClient client = new MongoClient(options);
 ```
 
-It's also possible to combine `MongoClientOptions` with `MongoClientURI`, for situations where your application needs to set some options
+It's also possible to combine [`MongoClientOptions`]({{< apiref "com/mongodb/MongoClientOptions" >}}) with 
+[`MongoClientURI`]({{< apiref "com/mongodb/MongoClientURI" >}}), for situations where your application needs to set some options
 in code but others via the connection string:
 
 ```java

docs/reference/content/whats-new/index.md

@@ -10,11 +10,12 @@ title = "What's New"
 
 Key features of the 3.0 driver include:
 
-- A generic [MongoCollection](http://api.mongodb.org/java/3.0/com/mongodb/client/MongoCollection.html) interface that complies with a new cross-driver [CRUD specification](https://github.com/mongodb/specifications/blob/master/source/crud/crud.rst).
+- A generic [`MongoCollection`]({{< apiref "com/mongodb/client/MongoCollection" >}}) interface that complies with a new cross-driver 
+[CRUD specification](https://github.com/mongodb/specifications/blob/master/source/crud/crud.rst).
 - A new [asynchronous API](https://github.com/mongodb/mongo-java-driver/tree/master/driver-async) that can leverage either 
 [Netty](http://netty.io/) or Java 7's 
 [AsynchronousSocketChannel](http://docs.oracle .com/javase/7/docs/api/java/nio/channels/AsynchronousSocketChannel.html)
-- A new [Codec](http://api.mongodb.org/java/3.0/org/bson/codecs/Codec.html) infrastructure that you can use to build high-performance
+- A new [`Codec`]({{< apiref "org/bson/codecs/Codec" >}}) infrastructure that you can use to build high-performance
  encoders and decoders without requiring an intermediate Map instance.
 - A new core driver on top of which you can build alternative or experimental driver APIs