Merge pull request #127 from saghm/1.4

Some changes to reflect Rust 1.4 update

Author: vkarpov15

README.md

@@ -1,35 +1,39 @@
-[![Travis](https://travis-ci.org/mongodb-labs/mongo-rust-driver-prototype.svg)](https://travis-ci.org/mongodb-labs/mongo-rust-driver-prototype)
-[![Crates.io](https://img.shields.io/crates/v/mongodb.svg)](https://crates.io/crates/mongodb)
-[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
+[![Travis](https://travis-ci.org/mongodb-labs/mongo-rust-driver-prototype.svg)](https://travis-ci.org/mongodb-labs/mongo-rust-driver-prototype)[![Crates.io](https://img.shields.io/crates/v/mongodb.svg)](https://crates.io/crates/mongodb)[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
 
 MongoDB Rust Driver Prototype
 =============================
 
-This branch contains active development on a new driver written for Rust 1.0.
+This branch contains active development on a new driver written for Rust 1.x.
 
 The API and implementation are currently subject to change at any time. You must not use this driver in production as it is still under development and is in no way supported by MongoDB Inc. We absolutely encourage you to experiment with it and provide us feedback on the API, design, and implementation. Bug reports and suggestions for improvements are welcomed, as are pull requests.
 
-## Installation
+Installation
+------------
 
 #### Dependencies
-- [Rust 1.0 with Cargo](http://rust-lang.org)
+
+-	[Rust 1.x with Cargo](http://rust-lang.org)
 
 #### Importing
-The 1.0 driver is available on crates.io. To use the MongoDB driver in your code, add the bson and mongodb packages to your ```Cargo.toml```:
+
+The 1.0 driver is available on crates.io. To use the MongoDB driver in your code, add the bson and mongodb packages to your `Cargo.toml`:
+
 ```
 [dependencies]
-bson = "0.1.3"
+bson = "0.1.4"
 mongodb = "0.1.0"
 ```
 
 Then, import the bson and driver libraries within your code.
+
 ```rust
 #[macro_use(bson, doc)]
 extern crate bson;
 extern crate mongodb;
 ```
 
-## Examples
+Examples
+--------
 
 Here's a basic example of driver usage:
 
@@ -69,5 +73,7 @@ fn main() {
 }
 ```
 
-## Documentation
-Documentation is built using Cargo. The latest documentation can be found [here](https://mongodb-labs.github.io/mongo-rust-driver-prototype/mongodb). Generated documentation using ```cargo doc``` can be found under the _target/doc/_ folder.
+Documentation
+-------------
+
+Documentation is built using Cargo. The latest documentation can be found [here](https://mongodb-labs.github.io/mongo-rust-driver-prototype/mongodb). Generated documentation using `cargo doc` can be found under the *target/doc/* folder.

src/cursor.rs

@@ -16,7 +16,7 @@
 //!
 //! let mut cursor = coll.find(None, None).unwrap();
 //! for result in cursor {
-//!     let doc = result.ok().expect("Received network error during cursor operations.");
+//!     let doc = result.expect("Received network error during cursor operations.");
 //!     if let Some(&Bson::String(ref value)) = doc.get("spirit_animal") {
 //!         println!("My spirit animal is {}", value);
 //!     }

src/lib.rs

@@ -12,18 +12,18 @@
 //! #
 //! // Direct connection to a server. Will not look for other servers in the topology.
 //! let client = Client::connect("localhost", 27017)
-//!     .ok().expect("Failed to initialize client.");
+//!     .expect("Failed to initialize client.");
 //!
 //! // Connect to a complex server topology, such as a replica set
 //! // or sharded cluster, using a connection string uri.
 //! let client = Client::with_uri("mongodb://localhost:27017,localhost:27018/")
-//!     .ok().expect("Failed to initialize client.");
+//!     .expect("Failed to initialize client.");
 //!
 //! // Specify a read preference, and rely on the driver to find secondaries.
 //! let mut options = ClientOptions::new();
 //! options.read_preference = Some(ReadPreference::new(ReadMode::SecondaryPreferred, None));
 //! let client = Client::with_uri_and_options("mongodb://localhost:27017/", options)
-//!     .ok().expect("Failed to initialize client.");
+//!     .expect("Failed to initialize client.");
 //! ```
 //!
 //! ## Interacting with MongoDB Collections

tests/apm/mod.rs

@@ -23,7 +23,7 @@ fn timed_query(_client: Client, command_result: &CommandResult) {
 
 #[test]
 fn command_duration() {
-    let mut client = Client::connect("localhost", 27017).ok().expect("damn it!");
+    let mut client = Client::connect("localhost", 27017).expect("damn it!");
     let db = client.db("test");
     let coll = db.collection("event_hooks");
     coll.drop().unwrap();

tests/client/client.rs

@@ -6,27 +6,27 @@ use std::thread;
 #[test]
 fn database_names() {
     let client = Client::connect("localhost", 27018).unwrap();
-    let state_results = client.database_names().ok().expect("Failed to execute database_names.");
+    let state_results = client.database_names().expect("Failed to execute database_names.");
     for name in state_results {
         if name != "local" {
-            client.drop_database(&name[..]).ok().expect("Failed to drop database from server.");
+            client.drop_database(&name[..]).expect("Failed to drop database from server.");
         }
     }
 
-    let base_results = client.database_names().ok().expect("Failed to execute database_names.");
+    let base_results = client.database_names().expect("Failed to execute database_names.");
     assert_eq!(1, base_results.len());
     assert_eq!("local", base_results[0]);
 
     // Build dbs
     let db1 = client.db("new_db");
     let db2 = client.db("new_db_2");
     db1.collection("test1").insert_one(bson::Document::new(), None)
-        .ok().expect("Failed to insert placeholder document into collection");
+        .expect("Failed to insert placeholder document into collection");
     db2.collection("test2").insert_one(bson::Document::new(), None)
-        .ok().expect("Failed to insert placeholder document into collection");
+        .expect("Failed to insert placeholder document into collection");
 
     // Check new dbs
-    let results = client.database_names().ok().expect("Failed to execute database_names.");
+    let results = client.database_names().expect("Failed to execute database_names.");
     assert_eq!(3, results.len());
     assert!(results.contains(&"local".to_owned()));
     assert!(results.contains(&"new_db".to_owned()));
@@ -37,48 +37,48 @@ fn database_names() {
 #[test]
 fn is_master() {
     let client = Client::connect("localhost", 27017).unwrap();
-    let res = client.is_master().ok().expect("Failed to execute is_master.");
+    let res = client.is_master().expect("Failed to execute is_master.");
     assert!(res);
 }
 
 #[test]
 fn is_sync() {
     let client = Client::connect("localhost", 27018).unwrap();
-    let state_results = client.database_names().ok().expect("Failed to execute database_names.");
+    let state_results = client.database_names().expect("Failed to execute database_names.");
     for name in state_results {
         if name != "local" {
-            client.drop_database(&name[..]).ok().expect("Failed to drop database from server.");
+            client.drop_database(&name[..]).expect("Failed to drop database from server.");
         }
     }
 
     let client1 = client.clone();
     let client2 = client.clone();
 
-    let base_results = client.database_names().ok().expect("Failed to execute database_names.");
+    let base_results = client.database_names().expect("Failed to execute database_names.");
     assert_eq!(1, base_results.len());
     assert_eq!("local", base_results[0]);
 
     let child1 = thread::spawn(move || {
         let db = client1.db("concurrent_db");
         db.collection("test1").insert_one(bson::Document::new(), None)
-            .ok().expect("Failed to insert placeholder document into collection");
-        let results = client1.database_names().ok().expect("Failed to execute database_names.");
+            .expect("Failed to insert placeholder document into collection");
+        let results = client1.database_names().expect("Failed to execute database_names.");
         assert!(results.contains(&"concurrent_db".to_owned()));
     });
 
     let child2 = thread::spawn(move || {
         let db = client2.db("concurrent_db_2");
         db.collection("test2").insert_one(bson::Document::new(), None)
-            .ok().expect("Failed to insert placeholder document into collection");
-        let results = client2.database_names().ok().expect("Failed to execute database_names.");
+            .expect("Failed to insert placeholder document into collection");
+        let results = client2.database_names().expect("Failed to execute database_names.");
         assert!(results.contains(&"concurrent_db_2".to_owned()));
     });
 
     let _ = child1.join();
     let _ = child2.join();
 
     // Check new dbs
-    let results = client.database_names().ok().expect("Failed to execute database_names.");
+    let results = client.database_names().expect("Failed to execute database_names.");
     assert_eq!(3, results.len());
     assert!(results.contains(&"local".to_owned()));
     assert!(results.contains(&"concurrent_db".to_owned()));