last review edits + fmt

meilisearch-http/src/helpers/authentication.rs

@@ -3,7 +3,7 @@ use std::pin::Pin;
 use std::rc::Rc;
 use std::task::{Context, Poll};
 
-use actix_web::dev::{Transform, Service, ServiceResponse, ServiceRequest};
+use actix_web::dev::{Service, ServiceRequest, ServiceResponse, Transform};
 use actix_web::web;
 use futures::future::{err, ok, Future, Ready};
 
@@ -70,10 +70,16 @@ where
         let auth_header = match req.headers().get("X-Meili-API-Key") {
             Some(auth) => match auth.to_str() {
                 Ok(auth) => auth,
-                Err(_) => return Box::pin(err(ResponseError::from(Error::MissingAuthorizationHeader).into())),
+                Err(_) => {
+                    return Box::pin(err(
+                        ResponseError::from(Error::MissingAuthorizationHeader).into()
+                    ))
+                }
             },
             None => {
-                return Box::pin(err(ResponseError::from(Error::MissingAuthorizationHeader).into()));
+                return Box::pin(err(
+                    ResponseError::from(Error::MissingAuthorizationHeader).into()
+                ));
             }
         };
 
@@ -93,9 +99,10 @@ where
         if authenticated {
             Box::pin(svc.call(req))
         } else {
-            Box::pin(err(
-                ResponseError::from(Error::InvalidToken(auth_header.to_string())).into()
+            Box::pin(err(ResponseError::from(Error::InvalidToken(
+                auth_header.to_string(),
             ))
+            .into()))
         }
     }
 }

meilisearch-http/src/helpers/compression.rs

@@ -1,9 +1,9 @@
-use flate2::Compression;
 use flate2::read::GzDecoder;
 use flate2::write::GzEncoder;
+use flate2::Compression;
 use std::fs::{create_dir_all, File};
 use std::path::Path;
-use tar::{Builder, Archive};
+use tar::{Archive, Builder};
 
 use crate::error::Error;
 

meilisearch-http/src/helpers/mod.rs

@@ -1,6 +1,4 @@
 pub mod authentication;
-//pub mod normalize_path;
 pub mod compression;
 
 pub use authentication::Authentication;
-//pub use normalize_path::NormalizePath;

meilisearch-http/src/helpers/normalize_path.rs

@@ -1,86 +0,0 @@
-/// From https://docs.rs/actix-web/3.0.0-alpha.2/src/actix_web/middleware/normalize.rs.html#34
-use actix_web::http::Error;
-use actix_service::{Service, Transform};
-use actix_web::{
-    dev::ServiceRequest,
-    dev::ServiceResponse,
-    http::uri::{PathAndQuery, Uri},
-};
-use futures::future::{ok, Ready};
-use regex::Regex;
-use std::task::{Context, Poll};
-pub struct NormalizePath;
-
-impl<S, B> Transform<S> for NormalizePath
-where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
-    S::Future: 'static,
-{
-    type Request = ServiceRequest;
-    type Response = ServiceResponse<B>;
-    type Error = Error;
-    type InitError = ();
-    type Transform = NormalizePathNormalization<S>;
-    type Future = Ready<Result<Self::Transform, Self::InitError>>;
-
-    fn new_transform(&self, service: S) -> Self::Future {
-        ok(NormalizePathNormalization {
-            service,
-            merge_slash: Regex::new("//+").unwrap(),
-        })
-    }
-}
-
-pub struct NormalizePathNormalization<S> {
-    service: S,
-    merge_slash: Regex,
-}
-
-impl<S, B> Service for NormalizePathNormalization<S>
-where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
-    S::Future: 'static,
-{
-    type Request = ServiceRequest;
-    type Response = ServiceResponse<B>;
-    type Error = Error;
-    type Future = S::Future;
-
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.service.poll_ready(cx)
-    }
-
-    fn call(&mut self, mut req: ServiceRequest) -> Self::Future {
-        let head = req.head_mut();
-
-        // always add trailing slash, might be an extra one
-        let path = head.uri.path().to_string() + "/";
-
-        if self.merge_slash.find(&path).is_some() {
-            // normalize multiple /'s to one /
-            let path = self.merge_slash.replace_all(&path, "/");
-
-            let path = if path.len() > 1 {
-                path.trim_end_matches('/')
-            } else {
-                &path
-            };
-
-            let mut parts = head.uri.clone().into_parts();
-            let pq = parts.path_and_query.as_ref().unwrap();
-
-            let path = if let Some(q) = pq.query() {
-                bytes::Bytes::from(format!("{}?{}", path, q))
-            } else {
-                bytes::Bytes::copy_from_slice(path.as_bytes())
-            };
-            parts.path_and_query = Some(PathAndQuery::from_maybe_shared(path).unwrap());
-
-            let uri = Uri::from_parts(parts).unwrap();
-            req.match_info_mut().get_mut().update(&uri);
-            req.head_mut().uri = uri;
-        }
-
-        self.service.call(req)
-    }
-}