Docs: updated for 1.1.0-rc0

Author: rozza

docs/landing/data/releases.toml

@@ -2,6 +2,11 @@ driverName = "mongo-scala-driver"
 githubRepo = "mongo-scala-driver"
 current = "1.0.1"
 
+[[versions]]
+  version = "1.1.0-rc0"
+  docs = "./1.1"
+  api = "./1.1/scaladoc"
+
 [[versions]]
   version = "1.0.1"
   status = "current"

docs/landing/static/versions.json

@@ -1 +1 @@
-[{"version": "1.0"}]
+[{"version": "1.1"}, {"version": "1.0"}]

docs/reference/config.toml

@@ -1,4 +1,4 @@
-baseurl = "/mongo-scala-driver/1.0"
+baseurl = "/mongo-scala-driver/1.1"
 languageCode = "en-us"
 title = "MongoDB Scala Driver"
 theme = "mongodb"

docs/reference/content/builders/aggregation.md

@@ -65,6 +65,14 @@ This example simply projects the `qty` field into a new field called `quantity`.
 project(computed("quantity", "$qty"))
 ```
 
+### Sample
+The [`$sample`]({{< docsref "reference/operator/aggregation/sample/" >}}) pipeline stage randomly select N documents from its input.
+This example creates a pipeline stage that randomly selects 5 documents from the collection:
+
+```scala
+sample(5)
+```
+
 ### Sort
 
 The [`$sort`]({{< docsref "reference/operator/aggregation/sort/" >}}) pipeline stage passes all documents to the next stage, 
@@ -101,6 +109,18 @@ This example limits the number of documents to `10`:
 limit(10)
 ```
 
+### Lookup
+
+Starting in 3.2, MongoDB provides a new [`$lookup`]({{< docsref "reference/operator/aggregation/lookup/" >}}) pipeline stage 
+that performs a left outer join with another collection to filter in documents from the joined collection for processing.
+
+This example performs a left outer join on the `fromCollection` collection, joining the `local` field to the `from` field and outputted in 
+the `joinedOutput` field:
+
+```scala
+lookup("fromCollection", "local", "from", "joinedOutput")
+```
+
 ### Group
 
 The [`$group`]({{< docsref "reference/operator/aggregation/group/" >}}) pipeline stage groups documents by some specified 
@@ -130,6 +150,19 @@ This example outputs, for each document, a document for each element in the `siz
 unwind("$sizes")
 ```
 
+Available with MongoDB 3.2, this example also includes any documents that have missing or `null` values for the `$sizes` field or where 
+the `$sizes` list is empty:
+
+```scala
+unwind("$sizes", UnwindOptions().preserveNullAndEmptyArrays(true))
+```
+
+Available with MongoDB 3.2, this example unwinds the `sizes` array and also outputs the array index into the `$position` field:
+
+```scala
+unwind("$sizes", UnwindOptions().includeArrayIndex("$position"))
+```
+
 ### Out
 
 The [`$out`]({{< docsref "reference/operator/aggregation/out/" >}}) pipeline stage outputs all documents to the specified 

docs/reference/content/builders/filters.md

@@ -151,7 +151,39 @@ This example assumes a collection that has a text index in the field `abstract`.
 containing the term `coffee`:
 
 ```scala
-text("abstract", "coffee")
+text("coffee")
+```
+
+Available with MongoDB 3.2, a version 3 text index allows case-sensitive searches. This example selects documents that have an 
+`abstract` field containing the exact term `coffee`:
+
+```scala
+text("coffee", TextSearchOptions().caseSensitive(true))
+```
+
+Available with MongoDB 3.2, a version 3 text index allows diacritic-sensitive searches. This example selects documents that have an 
+`abstract` field containing the exact term `café`:
+
+```scala
+text("café", TextSearchOptions().diacriticSensitive(true))
+```
+
+### Bitwise
+
+The bitwise query operators, available with MongoDB 3.2 include:
+
+- `bitsAllSet`: Selects documents where the all the specified bits of a field are set (i.e. 1).
+- `bitsAllClear`: Selects documents where the all the specified bits of a field are clear (i.e. 0).
+- `bitsAnySet`: Selects documents where at least one of the specified bits of a field are set (i.e. 1).
+- `bitsAnyClear`: Selects documents where at least one of the specified bits of a field are clear (i.e. 0)
+
+
+#### Examples
+
+The example selects documents that have a `bitField` field with bits set at positions of the corresponding bitmask `50` (i.e. `00110010`):
+
+```scala
+bitsAllSet("bitField", 50)
 ```
 
 ### Geospatial

docs/reference/content/getting-started/installation-guide.md

@@ -17,4 +17,4 @@ The recommended way to get started using the driver in your project is with a de
 ## MongoDB Scala Driver
 The MongoDB Scala Driver
 
-{{< install artifactId="mongo-scala-driver" version="1.0.1" mongoDriverVersion="3.1.0" scalaVersion="2.11">}}
+{{< install artifactId="mongo-scala-driver" version="1.1.0-rc0" mongoDriverVersion="3.2.0-rc0" scalaVersion="2.11">}}

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

@@ -90,8 +90,8 @@ collection.drop().headResult()
 
 MongoDB supports secondary indexes. To create an index, you just
 specify the field or combination of fields, and for each field specify the direction of the index for that field.
-For `1` ascending  or `-1` for descending. The following creates an ascending index on the `i` field by using the 
-[`Sorts.ascending`]({{< apiref "org.mongodb.scala.model.Sorts$@ascending(fieldNames:String*):org.bson.conversions.Bson">}}) helper:
+For `1` ascending  or `-1` for descending. 
+We can use the [`Indexes`]({{< relref "builders/indexes.md">}}) helpers to create index keys:
 
 ```scala
 collection.createIndex(ascending("i")).printResults("Created an index named: ")
@@ -116,7 +116,8 @@ The example should print the following indexes:
 
 MongoDB also provides text indexes to support text search of string
 content. Text indexes can include any field whose value is a string or
-an array of string elements. 
+an array of string elements. To create a text index use the [`Indexes.text`]({{< relref "builders/indexes.md#text-index">}})
+static helper:
 
 The following example creates a text index by specifying the string literal "text" in the index document, then insert some sample documents.
 Using a for comprehension we can combine the two operations:
@@ -135,14 +136,14 @@ indexAndInsert.results()
 ```
 
 As of MongoDB 2.6, text indexes are now integrated into the main query
-language and enabled by default (here we use the [`Filters.text`]({{< coreapiref "com/mongodb/client/model/Filters.html#text-java.lang.String-">}}) helper):
+language and enabled by default (here we use the [`Filters.text`]({{< relref "builders/filters.md#evaluation">}}) helper):
 
 ```scala
 // Find using the text index
 collection.count(text("textual content -irrelevant")).printResults("Text search matches: ")
 
 // Find using the $language operator
-val textSearch: Bson = text("textual content -irrelevant", "english")
+val textSearch: Bson = text("textual content -irrelevant", TextSearchOptions().language("english"))
 collection.count(textSearch).printResults("Text search matches (english): ")
 
 // Find the highest scoring match

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

@@ -252,9 +252,9 @@ will eventually print just one document:
 ```
 
 {{% note %}}
-Use the [Filters]({{< apiref "org.mongodb.scala.model.Filters$">}}), [Sorts]({{< apiref "org.mongodb.scala.model.Sorts$">}}), 
-[Projections]({{< apiref "org.mongodb.scala.model.Projections$">}}) and [Updates]({{< apiref "org.mongodb.scala.model.Updates$">}}) 
-helpers for simple and concise ways of building up queries and updates
+Use the [`Filters`]({{< relref "builders/filters.md">}}), [`Sorts`]({{< relref "builders/sorts.md">}}),
+[`Projections`]({{< relref "builders/projections.md">}}) and [`Updates`]({{< relref "builders/updates.md">}})
+helpers for simple and concise ways of building up queries.
 {{% /note %}}
 
 ## Get a Set of Documents with a Query
@@ -294,6 +294,38 @@ Below we'll sort the collection, exclude the `_id` field and output the first ma
 collection.find().projection(excludeId()).first().printHeadResult()
 ```
 
+## Aggregations
+
+Sometimes we need to aggregate the data stored in MongoDB. The [`Aggregates`]({{< relref "builders/aggregation.md" >}}) helper provides 
+builders for each of type of aggregation stage.
+
+Below we'll do a simple two step transformation that will calculate the value of `i * 10`. First we find all Documents 
+where `i > 0` by using the [`Aggregates.filter`]({{< relref "builders/aggregation.md#filter" >}}) 
+helper. Then we reshape the document by using [`Aggregates.project`]({{< relref "builders/aggregation.md#project" >}}) 
+in conjunction with the [`$multiply`]({{< docsref "reference/operator/aggregation/multiply/" >}}) operator to calculate the "`ITimes10`" 
+value:
+
+```scala
+collection.aggregate(Seq(filter(gt("i", 0)),
+  project(Document("""{ITimes10: {$multiply: ["$i", 10]}}""")))
+).printResults()
+```
+
+For [`$group`]({{< relref "builders/aggregation.md#group" >}}) operations use the 
+[`Accumulators`]({{< apiref "com/mongodb/client/model/Accumulators" >}}) helper for any 
+[accumulator operations]({{< docsref "reference/operator/aggregation/group/#accumulator-operator" >}}). Below we sum up all the values of 
+`i` by using the [`Aggregates.group`]({{< relref "builders/aggregation.md#group" >}}) helper in conjunction with the 
+[`Accumulators.sum`]({{< apiref "com/mongodb/client/model/Accumulators#sum-java.lang.String-TExpression-" >}}) helper:
+
+```java
+collection.aggregate(singletonList(group(null, sum("total", "$i")))).first(printDocument);
+```
+
+{{% note %}}
+Currently, there are no helpers for [aggregation expressions]({{< docsref "meta/aggregation-quick-reference/#aggregation-expressions" >}}). 
+Use the [`Document.parse()`]({{< relref "bson/extended-json.md" >}}) helper to quickly build aggregation expressions from extended JSON.
+{{% /note %}}
+
 ## Updating documents
 
 There are numerous [update operators](http://docs.mongodb.org/manual/reference/operator/update-field/)

docs/reference/data/mongodb.toml

@@ -1,9 +1,9 @@
 githubUser = "mongodb"
 githubRepo = "mongo-scala-driver"
 githubBranch = "master"
-currentVersion = "1.0"
+currentVersion = "1.1"
 highlightTheme = "idea.css"
 apiUrl = "/scaladoc/index.html"
-coreApiUrl = "http://api.mongodb.org/java/3.1/"
-coreDocsUrl = "http://mongodb.github.io/mongo-java-driver/3.1/"
-mongoDriverVersion = "3.1.0"               # Update in installation-guide.md
+coreApiUrl = "http://api.mongodb.org/java/3.2/"
+coreDocsUrl = "http://mongodb.github.io/mongo-java-driver/3.2/"
+mongoDriverVersion = "3.2.0-rc0"               # Update in installation-guide.md

examples/src/test/scala/tour/QuickTour.scala

@@ -19,6 +19,7 @@ package tour
 import scala.collection.immutable.IndexedSeq
 
 import org.mongodb.scala._
+import org.mongodb.scala.model.Aggregates._
 import org.mongodb.scala.model.Filters._
 import org.mongodb.scala.model.Projections._
 import org.mongodb.scala.model.Sorts._
@@ -88,6 +89,11 @@ object QuickTour {
     // Projection
     collection.find().projection(excludeId()).first().printHeadResult()
 
+    //Aggregation
+    collection.aggregate(Seq(filter(gt("i", 0)),
+      project(Document("""{ITimes10: {$multiply: ["$i", 10]}}""")))
+    ).printResults()
+
     // Update One
     collection.updateOne(equal("i", 10), set("i", 110)).printHeadResult("Update Result: ")