Rustfmt

src/backup.rs

@@ -171,9 +171,7 @@ impl<'a, 'b> Backup<'a, 'b> {
     ///
     /// Will return `Err` if the underlying `sqlite3_backup_init` call returns
     /// `NULL`.
-    pub fn new(from: &'a Connection,
+    pub fn new(from: &'a Connection, to: &'b mut Connection) -> Result<Backup<'a, 'b>> {
-               to: &'b mut Connection)
-               -> Result<Backup<'a, 'b>> {
         Backup::new_with_names(from, DatabaseName::Main, to, DatabaseName::Main)
     }
 

src/blob.rs

@@ -352,7 +352,8 @@ mod test {
 
         {
             // ... but it should've written the first 10 bytes
-            let mut blob = db.blob_open(DatabaseName::Main, "test", "content", rowid, false).unwrap();
+            let mut blob = db.blob_open(DatabaseName::Main, "test", "content", rowid, false)
+                             .unwrap();
             let mut bytes = [0u8; 10];
             assert_eq!(10, blob.read(&mut bytes[..]).unwrap());
             assert_eq!(b"0123456701", &bytes);
@@ -369,7 +370,8 @@ mod test {
 
         {
             // ... but it should've written the first 10 bytes
-            let mut blob = db.blob_open(DatabaseName::Main, "test", "content", rowid, false).unwrap();
+            let mut blob = db.blob_open(DatabaseName::Main, "test", "content", rowid, false)
+                             .unwrap();
             let mut bytes = [0u8; 10];
             assert_eq!(10, blob.read(&mut bytes[..]).unwrap());
             assert_eq!(b"aaaaaaaaaa", &bytes);

src/error.rs

@@ -85,13 +85,18 @@ impl fmt::Display for Error {
         match self {
             &Error::SqliteFailure(ref err, None) => err.fmt(f),
             &Error::SqliteFailure(_, Some(ref s)) => write!(f, "{}", s),
-            &Error::SqliteSingleThreadedMode => write!(f, "SQLite was compiled or configured for single-threaded use only"),
+            &Error::SqliteSingleThreadedMode => {
+                write!(f,
+                       "SQLite was compiled or configured for single-threaded use only")
+            }
             &Error::FromSqlConversionFailure(ref err) => err.fmt(f),
             &Error::Utf8Error(ref err) => err.fmt(f),
             &Error::NulError(ref err) => err.fmt(f),
             &Error::InvalidParameterName(ref name) => write!(f, "Invalid parameter name: {}", name),
             &Error::InvalidPath(ref p) => write!(f, "Invalid path: {}", p.to_string_lossy()),
-            &Error::ExecuteReturnedResults => write!(f, "Execute returned results - did you mean to call query?"),
+            &Error::ExecuteReturnedResults => {
+                write!(f, "Execute returned results - did you mean to call query?")
+            }
             &Error::QueryReturnedNoRows => write!(f, "Query returned no rows"),
             &Error::GetFromStaleRow => write!(f, "Attempted to get a value from a stale row"),
             &Error::InvalidColumnIndex(i) => write!(f, "Invalid column index: {}", i),
@@ -111,13 +116,17 @@ impl error::Error for Error {
         match self {
             &Error::SqliteFailure(ref err, None) => err.description(),
             &Error::SqliteFailure(_, Some(ref s)) => s,
-            &Error::SqliteSingleThreadedMode => "SQLite was compiled or configured for single-threaded use only",
+            &Error::SqliteSingleThreadedMode => {
+                "SQLite was compiled or configured for single-threaded use only"
+            }
             &Error::FromSqlConversionFailure(ref err) => err.description(),
             &Error::Utf8Error(ref err) => err.description(),
             &Error::InvalidParameterName(_) => "invalid parameter name",
             &Error::NulError(ref err) => err.description(),
             &Error::InvalidPath(_) => "invalid path",
-            &Error::ExecuteReturnedResults => "execute returned results - did you mean to call query?",
+            &Error::ExecuteReturnedResults => {
+                "execute returned results - did you mean to call query?"
+            }
             &Error::QueryReturnedNoRows => "query returned no rows",
             &Error::GetFromStaleRow => "attempted to get a value from a stale row",
             &Error::InvalidColumnIndex(_) => "invalid column index",

src/lib.rs

@@ -182,9 +182,7 @@ impl Connection {
     ///
     /// Will return `Err` if `path` cannot be converted to a C-compatible string or if the
     /// underlying SQLite open call fails.
-    pub fn open_with_flags<P: AsRef<Path>>(path: P,
+    pub fn open_with_flags<P: AsRef<Path>>(path: P, flags: OpenFlags) -> Result<Connection> {
-                                           flags: OpenFlags)
-        -> Result<Connection> {
         let c_path = try!(path_to_cstring(path.as_ref()));
         InnerConnection::open_with_flags(&c_path, flags).map(|db| {
             Connection {
@@ -359,7 +357,11 @@ impl Connection {
     ///
     /// Will return `Err` if `sql` cannot be converted to a C-compatible string or if the
     /// underlying SQLite call fails.
-    pub fn query_row_and_then<T, E, F>(&self, sql: &str, params: &[&ToSql], f: F) -> result::Result<T, E>
+    pub fn query_row_and_then<T, E, F>(&self,
+                                       sql: &str,
+                                       params: &[&ToSql],
+                                       f: F)
+                                       -> result::Result<T, E>
         where F: FnOnce(Row) -> result::Result<T, E>,
               E: convert::From<Error>
     {
@@ -542,9 +544,7 @@ impl Default for OpenFlags {
 }
 
 impl InnerConnection {
-    fn open_with_flags(c_path: &CString,
+    fn open_with_flags(c_path: &CString, flags: OpenFlags) -> Result<InnerConnection> {
-                       flags: OpenFlags)
-        -> Result<InnerConnection> {
         unsafe {
             // Before opening the database, we need to check that SQLite hasn't been
             // compiled or configured to be in single-threaded mode. If it has, we're
@@ -663,10 +663,7 @@ impl InnerConnection {
         unsafe { ffi::sqlite3_last_insert_rowid(self.db()) }
     }
 
-    fn prepare<'a>(&mut self,
+    fn prepare<'a>(&mut self, conn: &'a Connection, sql: &str) -> Result<Statement<'a>> {
-                   conn: &'a Connection,
-                   sql: &str)
-        -> Result<Statement<'a>> {
         if sql.len() >= ::std::i32::MAX as usize {
             return Err(error_from_sqlite_code(ffi::SQLITE_TOOBIG, None));
         }
@@ -790,7 +787,7 @@ impl<'conn> Statement<'conn> {
                 } else {
                     Ok(self.conn.changes())
                 }
-            },
+            }
             ffi::SQLITE_ROW => Err(Error::ExecuteReturnedResults),
             _ => Err(self.conn.decode_result(r).unwrap_err()),
         }
@@ -839,10 +836,7 @@ impl<'conn> Statement<'conn> {
     /// # Failure
     ///
     /// Will return `Err` if binding parameters fails.
-    pub fn query_map<'a, T, F>(&'a mut self,
+    pub fn query_map<'a, T, F>(&'a mut self, params: &[&ToSql], f: F) -> Result<MappedRows<'a, F>>
-                               params: &[&ToSql],
-                               f: F)
-        -> Result<MappedRows<'a, F>>
         where F: FnMut(&Row) -> T
     {
         let row_iter = try!(self.query(params));
@@ -1450,7 +1444,7 @@ mod test {
                 if version >= 3007016 {
                     assert_eq!(err.extended_code, ffi::SQLITE_CONSTRAINT_NOTNULL)
                 }
-            },
+            }
             err => panic!("Unexpected error {}", err),
         }
     }

src/named_params.rs

@@ -37,11 +37,7 @@ impl Connection {
     ///
     /// Will return `Err` if `sql` cannot be converted to a C-compatible string or if the
     /// underlying SQLite call fails.
-    pub fn query_row_named<T, F>(&self,
+    pub fn query_row_named<T, F>(&self, sql: &str, params: &[(&str, &ToSql)], f: F) -> Result<T>
-                                 sql: &str,
-                                 params: &[(&str, &ToSql)],
-                                 f: F)
-                                 -> Result<T>
         where F: FnOnce(Row) -> T
     {
         let mut stmt = try!(self.prepare(sql));
@@ -91,9 +87,7 @@ impl<'conn> Statement<'conn> {
     /// which case `query` should be used instead), or the underling SQLite call fails.
     pub fn execute_named(&mut self, params: &[(&str, &ToSql)]) -> Result<c_int> {
         try!(self.bind_parameters_named(params));
-        unsafe {
+        unsafe { self.execute_() }
-            self.execute_()
-        }
     }
 
     /// Execute the prepared statement with named parameter(s), returning an iterator over the
@@ -118,9 +112,7 @@ impl<'conn> Statement<'conn> {
     /// # Failure
     ///
     /// Will return `Err` if binding parameters fails.
-    pub fn query_named<'a>(&'a mut self,
+    pub fn query_named<'a>(&'a mut self, params: &[(&str, &ToSql)]) -> Result<Rows<'a>> {
-                           params: &[(&str, &ToSql)])
-                           -> Result<Rows<'a>> {
         self.reset_if_needed();
         try!(self.bind_parameters_named(params));
 
@@ -198,8 +190,10 @@ mod test {
         let mut stmt = db.prepare("INSERT INTO test (x, y) VALUES (:x, :y)").unwrap();
         stmt.execute_named(&[(":x", &"one")]).unwrap();
 
-        let result: Option<String> = db.query_row("SELECT y FROM test WHERE x = 'one'", &[],
+        let result: Option<String> = db.query_row("SELECT y FROM test WHERE x = 'one'",
-                                  |row| row.get(0)).unwrap();
+                                                  &[],
+                                                  |row| row.get(0))
+                                       .unwrap();
         assert!(result.is_none());
     }
 
@@ -213,8 +207,10 @@ mod test {
         stmt.execute_named(&[(":x", &"one")]).unwrap();
         stmt.execute_named(&[(":y", &"two")]).unwrap();
 
-        let result: String = db.query_row("SELECT x FROM test WHERE y = 'two'", &[],
+        let result: String = db.query_row("SELECT x FROM test WHERE y = 'two'",
-                                  |row| row.get(0)).unwrap();
+                                          &[],
+                                          |row| row.get(0))
+                               .unwrap();
         assert_eq!(result, "one");
     }
 }

src/transaction.rs

@@ -47,9 +47,7 @@ pub struct Transaction<'conn> {
 
 impl<'conn> Transaction<'conn> {
     /// Begin a new transaction. Cannot be nested; see `savepoint` for nested transactions.
-    pub fn new(conn: &Connection,
+    pub fn new(conn: &Connection, behavior: TransactionBehavior) -> Result<Transaction> {
-               behavior: TransactionBehavior)
-               -> Result<Transaction> {
         let query = match behavior {
             TransactionBehavior::Deferred => "BEGIN DEFERRED",
             TransactionBehavior::Immediate => "BEGIN IMMEDIATE",