fix: fmt

Author: sabify

src/async_connection_wrapper.rs

@@ -9,9 +9,7 @@
 //!   as replacement for the existing connection
 //!   implementations provided by diesel
 
-use futures_util::Future;
-use futures_util::Stream;
-use futures_util::StreamExt;
+use futures_util::{Future, Stream, StreamExt};
 use std::pin::Pin;
 
 /// This is a helper trait that allows to customize the
@@ -194,13 +192,15 @@ mod implementation {
         C: crate::AsyncConnection,
         B: BlockOn + Send,
     {
-        type Cursor<'conn, 'query> = AsyncCursorWrapper<'conn, C::Stream<'conn, 'query>, B>
-    where
-        Self: 'conn;
+        type Cursor<'conn, 'query>
+            = AsyncCursorWrapper<'conn, C::Stream<'conn, 'query>, B>
+        where
+            Self: 'conn;
 
-        type Row<'conn, 'query> = C::Row<'conn, 'query>
-    where
-        Self: 'conn;
+        type Row<'conn, 'query>
+            = C::Row<'conn, 'query>
+        where
+            Self: 'conn;
 
         fn load<'conn, 'query, T>(
             &'conn mut self,

src/mysql/row.rs

@@ -1,9 +1,15 @@
-use diesel::backend::Backend;
-use diesel::mysql::data_types::{MysqlTime, MysqlTimestampType};
-use diesel::mysql::{Mysql, MysqlType, MysqlValue};
-use diesel::row::{PartialRow, RowIndex, RowSealed};
-use mysql_async::consts::{ColumnFlags, ColumnType};
-use mysql_async::{Column, Row, Value};
+use diesel::{
+    backend::Backend,
+    mysql::{
+        data_types::{MysqlTime, MysqlTimestampType},
+        Mysql, MysqlType, MysqlValue,
+    },
+    row::{PartialRow, RowIndex, RowSealed},
+};
+use mysql_async::{
+    consts::{ColumnFlags, ColumnType},
+    Column, Row, Value,
+};
 use std::borrow::Cow;
 
 pub struct MysqlRow(pub(super) Row);
@@ -37,7 +43,11 @@ impl RowSealed for MysqlRow {}
 
 impl<'a> diesel::row::Row<'a, Mysql> for MysqlRow {
     type InnerPartialRow = Self;
-    type Field<'b> = MysqlField<'b> where Self: 'b, 'a: 'b;
+    type Field<'b>
+        = MysqlField<'b>
+    where
+        Self: 'b,
+        'a: 'b;
 
     fn field_count(&self) -> usize {
         self.0.columns_ref().len()

src/pg/row.rs

@@ -1,5 +1,7 @@
-use diesel::backend::Backend;
-use diesel::row::{Field, PartialRow, RowIndex, RowSealed};
+use diesel::{
+    backend::Backend,
+    row::{Field, PartialRow, RowIndex, RowSealed},
+};
 use std::{error::Error, num::NonZeroU32};
 use tokio_postgres::{types::Type, Row};
 
@@ -16,7 +18,11 @@ impl RowSealed for PgRow {}
 
 impl<'a> diesel::row::Row<'a, diesel::pg::Pg> for PgRow {
     type InnerPartialRow = Self;
-    type Field<'b> = PgField<'b> where Self: 'b, 'a: 'b;
+    type Field<'b>
+        = PgField<'b>
+    where
+        Self: 'b,
+        'a: 'b;
 
     fn field_count(&self) -> usize {
         self.row.len()

src/run_query_dsl/mod.rs

@@ -1,8 +1,7 @@
 use crate::AsyncConnection;
-use diesel::associations::HasTable;
-use diesel::query_builder::IntoUpdateTarget;
-use diesel::result::QueryResult;
-use diesel::AsChangeset;
+use diesel::{
+    associations::HasTable, query_builder::IntoUpdateTarget, result::QueryResult, AsChangeset,
+};
 use futures_util::{future, stream, FutureExt, Stream, StreamExt, TryFutureExt, TryStreamExt};
 use std::pin::Pin;
 
@@ -14,11 +13,13 @@ use std::pin::Pin;
 /// these traits.
 pub mod methods {
     use super::*;
-    use diesel::backend::Backend;
-    use diesel::deserialize::FromSqlRow;
-    use diesel::expression::QueryMetadata;
-    use diesel::query_builder::{AsQuery, QueryFragment, QueryId};
-    use diesel::query_dsl::CompatibleType;
+    use diesel::{
+        backend::Backend,
+        deserialize::FromSqlRow,
+        expression::QueryMetadata,
+        query_builder::{AsQuery, QueryFragment, QueryId},
+        query_dsl::CompatibleType,
+    };
     use futures_util::{Future, Stream, TryFutureExt};
 
     /// The `execute` method
@@ -92,17 +93,21 @@ pub mod methods {
         DB: QueryMetadata<T::SqlType>,
         ST: 'static,
     {
-        type LoadFuture<'conn> = future::MapOk<
+        type LoadFuture<'conn>
+            = future::MapOk<
             Conn::LoadFuture<'conn, 'query>,
             fn(Conn::Stream<'conn, 'query>) -> Self::Stream<'conn>,
-        > where Conn: 'conn;
+        >
+        where
+            Conn: 'conn;
 
-        type Stream<'conn> = stream::Map<
+        type Stream<'conn>
+            = stream::Map<
             Conn::Stream<'conn, 'query>,
-            fn(
-                QueryResult<Conn::Row<'conn, 'query>>,
-            ) -> QueryResult<U>,
-        >where  Conn: 'conn;
+            fn(QueryResult<Conn::Row<'conn, 'query>>) -> QueryResult<U>,
+        >
+        where
+            Conn: 'conn;
 
         fn internal_load(self, conn: &mut Conn) -> Self::LoadFuture<'_> {
             conn.load(self)