Rustfmt

src/lib.rs

@@ -222,12 +222,12 @@ impl Connection {
     pub fn open_with_flags<P: AsRef<Path>>(path: P, flags: OpenFlags) -> Result<Connection> {
         let c_path = try!(path_to_cstring(path.as_ref()));
         InnerConnection::open_with_flags(&c_path, flags).map(|db| {
-            Connection {
+                                                                 Connection {
                 db: RefCell::new(db),
                 cache: StatementCache::with_capacity(STATEMENT_CACHE_DEFAULT_CAPACITY),
                 path: Some(path.as_ref().to_path_buf()),
             }
-        })
+                                                             })
     }
 
     /// Open a new connection to an in-memory SQLite database.
@@ -241,12 +241,12 @@ impl Connection {
     pub fn open_in_memory_with_flags(flags: OpenFlags) -> Result<Connection> {
         let c_memory = try!(str_to_cstring(":memory:"));
         InnerConnection::open_with_flags(&c_memory, flags).map(|db| {
-            Connection {
+                                                                   Connection {
                 db: RefCell::new(db),
                 cache: StatementCache::with_capacity(STATEMENT_CACHE_DEFAULT_CAPACITY),
                 path: None,
             }
-        })
+                                                               })
     }
 
     /// Convenience method to run multiple SQL statements (that cannot take any parameters).
@@ -295,7 +295,8 @@ impl Connection {
     /// Will return `Err` if `sql` cannot be converted to a C-compatible string or if the
     /// underlying SQLite call fails.
     pub fn execute(&self, sql: &str, params: &[&ToSql]) -> Result<c_int> {
-        self.prepare(sql).and_then(|mut stmt| stmt.execute(params))
+        self.prepare(sql)
+            .and_then(|mut stmt| stmt.execute(params))
     }
 
     /// Convenience method to prepare and execute a single SQL statement with named parameter(s).
@@ -317,7 +318,8 @@ impl Connection {
     /// Will return `Err` if `sql` cannot be converted to a C-compatible string or if the
     /// underlying SQLite call fails.
     pub fn execute_named(&self, sql: &str, params: &[(&str, &ToSql)]) -> Result<c_int> {
-        self.prepare(sql).and_then(|mut stmt| stmt.execute_named(params))
+        self.prepare(sql)
+            .and_then(|mut stmt| stmt.execute_named(params))
     }
 
     /// Get the SQLite rowid of the most recent successful INSERT.
@@ -406,7 +408,9 @@ impl Connection {
         let mut stmt = try!(self.prepare(sql));
         let mut rows = try!(stmt.query(params));
 
-        rows.get_expected_row().map_err(E::from).and_then(|r| f(&r))
+        rows.get_expected_row()
+            .map_err(E::from)
+            .and_then(|r| f(&r))
     }
 
     /// Convenience method to execute a query that is expected to return a single row.
@@ -534,7 +538,9 @@ impl Connection {
                                           dylib_path: P,
                                           entry_point: Option<&str>)
                                           -> Result<()> {
-        self.db.borrow_mut().load_extension(dylib_path.as_ref(), entry_point)
+        self.db
+            .borrow_mut()
+            .load_extension(dylib_path.as_ref(), entry_point)
     }
 
     /// Get access to the underlying SQLite database connection handle.
@@ -849,7 +855,8 @@ impl InnerConnection {
                                     &mut c_stmt,
                                     ptr::null_mut())
         };
-        self.decode_result(r).map(|_| Statement::new(conn, RawStatement::new(c_stmt)))
+        self.decode_result(r)
+            .map(|_| Statement::new(conn, RawStatement::new(c_stmt)))
     }
 
     fn changes(&mut self) -> c_int {
@@ -999,12 +1006,15 @@ mod test {
         db.execute_batch("CREATE TABLE foo(x INTEGER)").unwrap();
 
         assert_eq!(1,
-                   db.execute("INSERT INTO foo(x) VALUES (?)", &[&1i32]).unwrap());
+                   db.execute("INSERT INTO foo(x) VALUES (?)", &[&1i32])
+                       .unwrap());
         assert_eq!(1,
-                   db.execute("INSERT INTO foo(x) VALUES (?)", &[&2i32]).unwrap());
+                   db.execute("INSERT INTO foo(x) VALUES (?)", &[&2i32])
+                       .unwrap());
 
         assert_eq!(3i32,
-                   db.query_row::<i32, _>("SELECT SUM(x) FROM foo", &[], |r| r.get(0)).unwrap());
+                   db.query_row::<i32, _>("SELECT SUM(x) FROM foo", &[], |r| r.get(0))
+                       .unwrap());
     }
 
     #[test]
@@ -1061,7 +1071,8 @@ mod test {
         assert_eq!(insert_stmt.execute(&[&2i32]).unwrap(), 1);
         assert_eq!(insert_stmt.execute(&[&3i32]).unwrap(), 1);
 
-        let mut query = db.prepare("SELECT x FROM foo WHERE x < ? ORDER BY x DESC").unwrap();
+        let mut query = db.prepare("SELECT x FROM foo WHERE x < ? ORDER BY x DESC")
+            .unwrap();
         {
             let mut rows = query.query(&[&4i32]).unwrap();
             let mut v = Vec::<i32>::new();
@@ -1146,8 +1157,10 @@ mod test {
     #[test]
     fn test_last_insert_rowid() {
         let db = checked_memory_handle();
-        db.execute_batch("CREATE TABLE foo(x INTEGER PRIMARY KEY)").unwrap();
-        db.execute_batch("INSERT INTO foo DEFAULT VALUES").unwrap();
+        db.execute_batch("CREATE TABLE foo(x INTEGER PRIMARY KEY)")
+            .unwrap();
+        db.execute_batch("INSERT INTO foo DEFAULT VALUES")
+            .unwrap();
 
         assert_eq!(db.last_insert_rowid(), 1);