Check code style with rustfmt on CI (#164)

.github/PULL_REQUEST_TEMPLATE.md

@@ -12,6 +12,7 @@ Check your PR fulfills the following:
 - [ ] Tests for the changes have been added / updated.
 - [ ] Documentation comments have been added / updated.
 - [ ] A changelog entry has been made for the appropriate packages.
+- [ ] Format code with the latest stable rustfmt
 
 
 ## Overview

.github/workflows/clippy-fmt.yml

@@ -0,0 +1,34 @@
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+name: Clippy and rustfmt Check
+jobs:
+  clippy_check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          components: rustfmt
+          profile: minimal
+          override: true
+      - name: Check with rustfmt
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly
+          components: clippy
+          profile: minimal
+          override: true
+      - name: Check with Clippy
+        uses: actions-rs/clippy-check@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --all-features --all --tests

.github/workflows/clippy.yml

@@ -1,20 +0,0 @@
-on:
-  pull_request:
-    types: [opened, synchronize, reopened]
-
-name: Clippy Check
-jobs:
-  clippy_check:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@master
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: nightly
-          components: clippy
-          profile: minimal
-          override: true
-      - uses: actions-rs/clippy-check@v1
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --all-features --all --tests

actix-codec/src/bcodec.rs

@@ -1,4 +1,4 @@
-use bytes::{Bytes, BytesMut, Buf};
+use bytes::{Buf, Bytes, BytesMut};
 use std::io;
 
 use super::{Decoder, Encoder};

actix-codec/src/framed.rs

@@ -271,7 +271,10 @@ impl<T, U> Framed<T, U> {
     }
 
     /// Flush write buffer to underlying I/O stream.
-    pub fn flush<I>(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), U::Error>>
+    pub fn flush<I>(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), U::Error>>
     where
         T: AsyncWrite,
         U: Encoder<I>,
@@ -304,7 +307,10 @@ impl<T, U> Framed<T, U> {
     }
 
     /// Flush write buffer and shutdown underlying I/O stream.
-    pub fn close<I>(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), U::Error>>
+    pub fn close<I>(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), U::Error>>
     where
         T: AsyncWrite,
         U: Encoder<I>,

actix-service/benches/and_then.rs

@@ -1,17 +1,15 @@
+use actix_service::boxed::BoxFuture;
+use actix_service::IntoService;
+use actix_service::Service;
 /// Benchmark various implementations of and_then
-
 use criterion::{criterion_main, Criterion};
 use futures_util::future::join_all;
+use futures_util::future::TryFutureExt;
 use std::cell::{RefCell, UnsafeCell};
-use std::task::{Context, Poll};
-use std::rc::Rc;
-use actix_service::{Service};
-use actix_service::IntoService;
 use std::future::Future;
 use std::pin::Pin;
-use futures_util::future::TryFutureExt;
-use actix_service::boxed::BoxFuture;
-
+use std::rc::Rc;
+use std::task::{Context, Poll};
 
 /*
  * Test services A,B for AndThen service implementations
@@ -30,7 +28,6 @@ async fn svc2(req: usize) -> Result<usize, ()> {
  * Cut down version of actix_service::AndThenService based on actix-service::Cell
  */
 
-
 struct AndThenUC<A, B>(Rc<UnsafeCell<(A, B)>>);
 
 impl<A, B> AndThenUC<A, B> {
@@ -52,7 +49,7 @@ impl<A,B> Clone for AndThenUC<A,B> {
 impl<A, B> Service for AndThenUC<A, B>
 where
     A: Service,
-    B: Service<Request = A::Response, Error = A::Error>
+    B: Service<Request = A::Response, Error = A::Error>,
 {
     type Request = A::Request;
     type Response = B::Response;
@@ -66,7 +63,7 @@ where
     fn call(&mut self, req: A::Request) -> Self::Future {
         let fut = unsafe { &mut *(*self.0).get() }.0.call(req);
         AndThenServiceResponse {
-			state: State::A(fut, Some(self.0.clone()))
+            state: State::A(fut, Some(self.0.clone())),
         }
     }
 }
@@ -117,11 +114,12 @@ where
                 this.state.set(State::Empty);
                 r
             }),
-            StateProj::Empty => panic!("future must not be polled after it returned `Poll::Ready`"),
+            StateProj::Empty => {
+                panic!("future must not be polled after it returned `Poll::Ready`")
+            }
         }
     }
 }
-
 
 /*
  * AndThenRC - AndThen service based on RefCell
@@ -148,7 +146,7 @@ where
 impl<A, B> Service for AndThenRC<A, B>
 where
     A: Service,
-	 B: Service<Request = A::Response, Error = A::Error>
+    B: Service<Request = A::Response, Error = A::Error>,
 {
     type Request = A::Request;
     type Response = B::Response;
@@ -162,7 +160,7 @@ where
     fn call(&mut self, req: A::Request) -> Self::Future {
         let fut = self.0.borrow_mut().0.call(req);
         AndThenServiceResponseRC {
-			 state: StateRC::A(fut, Some(self.0.clone()))
+            state: StateRC::A(fut, Some(self.0.clone())),
         }
     }
 }
@@ -213,11 +211,12 @@ where
                 this.state.set(StateRC::Empty);
                 r
             }),
-			 StateRCProj::Empty => panic!("future must not be polled after it returned `Poll::Ready`"),
+            StateRCProj::Empty => {
+                panic!("future must not be polled after it returned `Poll::Ready`")
+            }
         }
     }
 }
- 
 
 /*
  * AndThenRCFuture - AndThen service based on RefCell
@@ -247,7 +246,7 @@ where
     A: Service + 'static,
     A::Future: 'static,
     B: Service<Request = A::Response, Error = A::Error> + 'static,
- 	B::Future: 'static
+    B::Future: 'static,
 {
     type Request = A::Request;
     type Response = B::Response;
@@ -262,13 +261,10 @@ where
         let fut = self.0.borrow_mut().0.call(req);
         let core = self.0.clone();
         let fut2 = move |res| (*core).borrow_mut().1.call(res);
-		 Box::pin(
-			fut.and_then(fut2)
-		)
+        Box::pin(fut.and_then(fut2))
     }
 }
 
-
 /// Criterion Benchmark for async Service
 /// Should be used from within criterion group:
 /// ```rust,ignore
@@ -296,9 +292,7 @@ where
             // exclude request generation, it appears it takes significant time vs call (3us vs 1us)
             let start = std::time::Instant::now();
             // benchmark body
-            rt.block_on(async move {
-				join_all(srvs.iter_mut().map(|srv| srv.call(()))).await
-			});
+            rt.block_on(async move { join_all(srvs.iter_mut().map(|srv| srv.call(()))).await });
             let elapsed = start.elapsed();
             // check that at least first request succeeded
             elapsed
@@ -306,15 +300,34 @@ where
     });
 }
 
-
 pub fn service_benches() {
     let mut criterion: ::criterion::Criterion<_> =
         ::criterion::Criterion::default().configure_from_args();
-    bench_async_service(&mut criterion, AndThenUC::new(svc1.into_service(), svc2.into_service()), "AndThen with UnsafeCell");
-    bench_async_service(&mut criterion, AndThenRC::new(svc1.into_service(), svc2.into_service()), "AndThen with RefCell");
-    bench_async_service(&mut criterion, AndThenUC::new(svc1.into_service(), svc2.into_service()), "AndThen with UnsafeCell");
-    bench_async_service(&mut criterion, AndThenRC::new(svc1.into_service(), svc2.into_service()), "AndThen with RefCell");
-    bench_async_service(&mut criterion, AndThenRCFuture::new(svc1.into_service(), svc2.into_service()), "AndThen with RefCell via future::and_then");
+    bench_async_service(
+        &mut criterion,
+        AndThenUC::new(svc1.into_service(), svc2.into_service()),
+        "AndThen with UnsafeCell",
+    );
+    bench_async_service(
+        &mut criterion,
+        AndThenRC::new(svc1.into_service(), svc2.into_service()),
+        "AndThen with RefCell",
+    );
+    bench_async_service(
+        &mut criterion,
+        AndThenUC::new(svc1.into_service(), svc2.into_service()),
+        "AndThen with UnsafeCell",
+    );
+    bench_async_service(
+        &mut criterion,
+        AndThenRC::new(svc1.into_service(), svc2.into_service()),
+        "AndThen with RefCell",
+    );
+    bench_async_service(
+        &mut criterion,
+        AndThenRCFuture::new(svc1.into_service(), svc2.into_service()),
+        "AndThen with RefCell via future::and_then",
+    );
 }
 
 criterion_main!(service_benches);

actix-service/benches/unsafecell_vs_refcell.rs

@@ -1,10 +1,10 @@
+use actix_service::Service;
 use criterion::{criterion_main, Criterion};
 use futures_util::future::join_all;
-use std::cell::{RefCell, UnsafeCell};
-use std::task::{Context, Poll};
-use std::rc::Rc;
-use actix_service::{Service};
 use futures_util::future::{ok, Ready};
+use std::cell::{RefCell, UnsafeCell};
+use std::rc::Rc;
+use std::task::{Context, Poll};
 
 struct SrvUC(Rc<UnsafeCell<usize>>);
 
@@ -67,7 +67,6 @@ impl Service for SrvRC {
     }
 }
 
-
 /// Criterion Benchmark for async Service
 /// Should be used from within criterion group:
 /// ```rust,ignore
@@ -95,9 +94,7 @@ where
             // exclude request generation, it appears it takes significant time vs call (3us vs 1us)
             let start = std::time::Instant::now();
             // benchmark body
-            rt.block_on(async move {
-				join_all(srvs.iter_mut().map(|srv| srv.call(()))).await
-			});
+            rt.block_on(async move { join_all(srvs.iter_mut().map(|srv| srv.call(()))).await });
             let elapsed = start.elapsed();
             // check that at least first request succeeded
             elapsed
@@ -105,7 +102,6 @@ where
     });
 }
 
-
 pub fn service_benches() {
     let mut criterion: ::criterion::Criterion<_> =
         ::criterion::Criterion::default().configure_from_args();

actix-service/src/and_then.rs

@@ -1,12 +1,11 @@
+use std::cell::RefCell;
 use std::future::Future;
 use std::pin::Pin;
 use std::rc::Rc;
-use std::cell::RefCell;
 use std::task::{Context, Poll};
 
 use super::{Service, ServiceFactory};
 
-
 /// Service for the `and_then` combinator, chaining a computation onto the end
 /// of another service which completes successfully.
 ///
@@ -103,7 +102,9 @@ where
                 this.state.set(State::Empty);
                 r
             }),
-            StateProj::Empty => panic!("future must not be polled after it returned `Poll::Ready`"),
+            StateProj::Empty => {
+                panic!("future must not be polled after it returned `Poll::Ready`")
+            }
         }
     }
 }

actix-service/src/and_then_apply_fn.rs

@@ -1,8 +1,8 @@
+use std::cell::RefCell;
 use std::future::Future;
 use std::marker::PhantomData;
 use std::pin::Pin;
 use std::rc::Rc;
-use std::cell::RefCell;
 use std::task::{Context, Poll};
 
 use crate::{Service, ServiceFactory};
@@ -142,7 +142,9 @@ where
                 this.state.set(State::Empty);
                 r
             }),
-            StateProj::Empty => panic!("future must not be polled after it returned `Poll::Ready`"),
+            StateProj::Empty => {
+                panic!("future must not be polled after it returned `Poll::Ready`")
+            }
         }
     }
 }
@@ -296,8 +298,7 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_service() {
-        let mut srv = pipeline(ok)
-            .and_then_apply_fn(Srv, |req: &'static str, s| {
+        let mut srv = pipeline(ok).and_then_apply_fn(Srv, |req: &'static str, s| {
             s.call(()).map_ok(move |res| (req, res))
         });
         let res = lazy(|cx| srv.poll_ready(cx)).await;
@@ -310,8 +311,7 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_service_factory() {
-        let new_srv = pipeline_factory(|| ok::<_, ()>(fn_service(ok)))
-            .and_then_apply_fn(
+        let new_srv = pipeline_factory(|| ok::<_, ()>(fn_service(ok))).and_then_apply_fn(
             || ok(Srv),
             |req: &'static str, s| s.call(()).map_ok(move |res| (req, res)),
         );

actix-service/src/apply_cfg.rs

@@ -1,9 +1,9 @@
+use std::cell::RefCell;
 use std::future::Future;
 use std::marker::PhantomData;
 use std::pin::Pin;
-use std::task::{Context, Poll};
 use std::rc::Rc;
-use std::cell::RefCell;
+use std::task::{Context, Poll};
 
 use crate::{Service, ServiceFactory};
 

actix-service/src/then.rs

@@ -1,7 +1,7 @@
+use std::cell::RefCell;
 use std::future::Future;
 use std::pin::Pin;
 use std::rc::Rc;
-use std::cell::RefCell;
 use std::task::{Context, Poll};
 
 use super::{Service, ServiceFactory};
@@ -102,7 +102,9 @@ where
                 this.state.set(State::Empty);
                 r
             }),
-            StateProj::Empty => panic!("future must not be polled after it returned `Poll::Ready`"),
+            StateProj::Empty => {
+                panic!("future must not be polled after it returned `Poll::Ready`")
+            }
         }
     }
 }

router/src/de.rs

@@ -7,9 +7,13 @@ use crate::ResourcePath;
 macro_rules! unsupported_type {
     ($trait_fn:ident, $name:expr) => {
         fn $trait_fn<V>(self, _: V) -> Result<V::Value, Self::Error>
-            where V: Visitor<'de>
+        where
+            V: Visitor<'de>,
         {
-            Err(de::value::Error::custom(concat!("unsupported type: ", $name)))
+            Err(de::value::Error::custom(concat!(
+                "unsupported type: ",
+                $name
+            )))
         }
     };
 }
@@ -17,20 +21,25 @@ macro_rules! unsupported_type {
 macro_rules! parse_single_value {
     ($trait_fn:ident, $visit_fn:ident, $tp:tt) => {
         fn $trait_fn<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-            where V: Visitor<'de>
+        where
+            V: Visitor<'de>,
         {
             if self.path.len() != 1 {
                 Err(de::value::Error::custom(
-                    format!("wrong number of parameters: {} expected 1",
-                            self.path.len()).as_str()))
+                    format!("wrong number of parameters: {} expected 1", self.path.len())
+                        .as_str(),
+                ))
             } else {
-                let v = self.path[0].parse().map_err(
-                    |_| de::value::Error::custom(
-                        format!("can not parse {:?} to a {}", &self.path[0], $tp)))?;
+                let v = self.path[0].parse().map_err(|_| {
+                    de::value::Error::custom(format!(
+                        "can not parse {:?} to a {}",
+                        &self.path[0], $tp
+                    ))
+                })?;
                 visitor.$visit_fn(v)
             }
         }
-    }
+    };
 }
 
 pub struct PathDeserializer<'de, T: ResourcePath + 'de> {
@@ -268,14 +277,15 @@ impl<'de> Deserializer<'de> for Key<'de> {
 macro_rules! parse_value {
     ($trait_fn:ident, $visit_fn:ident, $tp:tt) => {
         fn $trait_fn<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-            where V: Visitor<'de>
+        where
+            V: Visitor<'de>,
         {
-            let v = self.value.parse().map_err(
-                |_| de::value::Error::custom(
-                    format!("can not parse {:?} to a {}", self.value, $tp)))?;
+            let v = self.value.parse().map_err(|_| {
+                de::value::Error::custom(format!("can not parse {:?} to a {}", self.value, $tp))
+            })?;
             visitor.$visit_fn(v)
         }
-    }
+    };
 }
 
 struct Value<'de> {

string/src/lib.rs

@@ -33,6 +33,13 @@ impl ByteString {
     }
 
     /// Creates a new `ByteString` from a Bytes.
+    ///
+    /// # Safety
+    /// This function is unsafe because it does not check the bytes passed to it
+    /// are valid UTF-8. If this constraint is violated,
+    /// it may cause memory unsafety issues with future users of the `ByteString`,
+    /// as we assume that `ByteString`s are valid UTF-8.
+    /// However, the most likely issue is that the data gets corrupted.
     pub const unsafe fn from_bytes_unchecked(src: Bytes) -> ByteString {
         Self(src)
     }