rustfmt

src/functions.rs

@@ -106,7 +106,10 @@ fn set_result<'a>(ctx: *mut sqlite3_context, result: &ToSqlOutput<'a>) {
             } else if length == 0 {
                 ffi::sqlite3_result_zeroblob(ctx, 0)
             } else {
-                ffi::sqlite3_result_blob(ctx, b.as_ptr() as *const c_void, length as c_int, ffi::SQLITE_TRANSIENT());
+                ffi::sqlite3_result_blob(ctx,
+                                         b.as_ptr() as *const c_void,
+                                         length as c_int,
+                                         ffi::SQLITE_TRANSIENT());
             }
         },
     }
@@ -139,7 +142,8 @@ impl<'a> ValueRef<'a> {
             ffi::SQLITE_FLOAT => ValueRef::Real(ffi::sqlite3_value_double(value)),
             ffi::SQLITE_TEXT => {
                 let text = ffi::sqlite3_value_text(value);
-                assert!(!text.is_null(), "unexpected SQLITE_TEXT value type with NULL data");
+                assert!(!text.is_null(),
+                        "unexpected SQLITE_TEXT value type with NULL data");
                 let s = CStr::from_ptr(text as *const c_char);
 
                 // sqlite3_value_text returns UTF8 data, so our unwrap here should be fine.
@@ -148,10 +152,12 @@ impl<'a> ValueRef<'a> {
             }
             ffi::SQLITE_BLOB => {
                 let blob = ffi::sqlite3_value_blob(value);
-                assert!(!blob.is_null(), "unexpected SQLITE_BLOB value type with NULL data");
+                assert!(!blob.is_null(),
+                        "unexpected SQLITE_BLOB value type with NULL data");
 
                 let len = ffi::sqlite3_value_bytes(value);
-                assert!(len >= 0, "unexpected negative return from sqlite3_value_bytes");
+                assert!(len >= 0,
+                        "unexpected negative return from sqlite3_value_bytes");
 
                 ValueRef::Blob(from_raw_parts(blob as *const u8, len as usize))
             }

src/lib.rs

@@ -888,7 +888,8 @@ impl<'conn> Statement<'conn> {
 
             #[cfg(feature = "blob")]
             ToSqlOutput::ZeroBlob(len) => {
-                return self.conn.decode_result(unsafe { ffi::sqlite3_bind_zeroblob(ptr, col, len) });
+                return self.conn
+                    .decode_result(unsafe { ffi::sqlite3_bind_zeroblob(ptr, col, len) });
             }
         };
         self.conn.decode_result(match value {
@@ -916,7 +917,11 @@ impl<'conn> Statement<'conn> {
                 } else if length == 0 {
                     ffi::sqlite3_bind_zeroblob(ptr, col, 0)
                 } else {
-                    ffi::sqlite3_bind_blob(ptr, col, b.as_ptr() as *const c_void, length as c_int, ffi::SQLITE_TRANSIENT())
+                    ffi::sqlite3_bind_blob(ptr,
+                                           col,
+                                           b.as_ptr() as *const c_void,
+                                           length as c_int,
+                                           ffi::SQLITE_TRANSIENT())
                 }
             },
         })
@@ -1153,7 +1158,8 @@ impl<'a> ValueRef<'a> {
             ffi::SQLITE_FLOAT => ValueRef::Real(ffi::sqlite3_column_double(raw, col)),
             ffi::SQLITE_TEXT => {
                 let text = ffi::sqlite3_column_text(raw, col);
-                assert!(!text.is_null(), "unexpected SQLITE_TEXT column type with NULL data");
+                assert!(!text.is_null(),
+                        "unexpected SQLITE_TEXT column type with NULL data");
                 let s = CStr::from_ptr(text as *const c_char);
 
                 // sqlite3_column_text returns UTF8 data, so our unwrap here should be fine.
@@ -1162,10 +1168,12 @@ impl<'a> ValueRef<'a> {
             }
             ffi::SQLITE_BLOB => {
                 let blob = ffi::sqlite3_column_blob(raw, col);
-                assert!(!blob.is_null(), "unexpected SQLITE_BLOB column type with NULL data");
+                assert!(!blob.is_null(),
+                        "unexpected SQLITE_BLOB column type with NULL data");
 
                 let len = ffi::sqlite3_column_bytes(raw, col);
-                assert!(len >= 0, "unexpected negative return from sqlite3_column_bytes");
+                assert!(len >= 0,
+                        "unexpected negative return from sqlite3_column_bytes");
 
                 ValueRef::Blob(from_raw_parts(blob as *const u8, len as usize))
             }

src/types/mod.rs

@@ -140,7 +140,8 @@ mod test {
 
         db.execute("INSERT INTO foo(i) VALUES (?)", &[&Value::Integer(10)]).unwrap();
 
-        assert_eq!(10i64, db.query_row("SELECT i FROM foo", &[], |r| r.get(0)).unwrap());
+        assert_eq!(10i64,
+                   db.query_row("SELECT i FROM foo", &[], |r| r.get(0)).unwrap());
     }
 
     #[test]

src/types/to_sql.rs

@@ -14,7 +14,9 @@ pub enum ToSqlOutput<'a> {
     ZeroBlob(i32),
 }
 
-impl<'a, T: ?Sized> From<&'a T> for ToSqlOutput<'a> where &'a T: Into<ValueRef<'a>> {
+impl<'a, T: ?Sized> From<&'a T> for ToSqlOutput<'a>
+    where &'a T: Into<ValueRef<'a>>
+{
     fn from(t: &'a T) -> Self {
         ToSqlOutput::Borrowed(t.into())
     }
@@ -59,7 +61,9 @@ to_sql_self!(i32);
 to_sql_self!(i64);
 to_sql_self!(f64);
 
-impl<'a, T: ?Sized> ToSql for &'a T where &'a T: Into<ToSqlOutput<'a>> {
+impl<'a, T: ?Sized> ToSql for &'a T
+    where &'a T: Into<ToSqlOutput<'a>>
+{
     fn to_sql(&self) -> Result<ToSqlOutput> {
         Ok(ToSqlOutput::from((*self).into()))
     }