clippy + fmt

meilisearch-http/src/analytics.rs

@@ -2,9 +2,9 @@ use std::hash::{Hash, Hasher};
 use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 
 use log::debug;
+use meilisearch_lib::MeiliSearch;
 use serde::Serialize;
 use siphasher::sip::SipHasher;
-use meilisearch_lib::MeiliSearch;
 
 use crate::Opt;
 

meilisearch-http/src/lib.rs

@@ -92,11 +92,7 @@ pub fn setup_temp_dir(db_path: impl AsRef<Path>) -> anyhow::Result<()> {
     Ok(())
 }
 
-pub fn configure_data(
-    config: &mut web::ServiceConfig,
-    data: MeiliSearch,
-    opt: &Opt,
-    ) {
+pub fn configure_data(config: &mut web::ServiceConfig, data: MeiliSearch, opt: &Opt) {
     let http_payload_size_limit = opt.http_payload_size_limit.get_bytes() as usize;
     config
         .app_data(data)
@@ -120,9 +116,9 @@ pub fn configure_auth(config: &mut web::ServiceConfig, opts: &Opt) {
         master: opts.master_key.clone(),
         private: None,
         public: None,
-        };
+    };
 
-        keys.generate_missing_api_keys();
+    keys.generate_missing_api_keys();
 
     let auth_config = if let Some(ref master_key) = keys.master {
         let private_key = keys.private.as_ref().unwrap();
@@ -139,8 +135,7 @@ pub fn configure_auth(config: &mut web::ServiceConfig, opts: &Opt) {
         AuthConfig::NoAuth
     };
 
-    config.app_data(auth_config)
-            .app_data(keys);
+    config.app_data(auth_config).app_data(keys);
 }
 
 #[cfg(feature = "mini-dashboard")]

meilisearch-http/src/main.rs

@@ -1,7 +1,7 @@
 use std::env;
 
 use actix_web::HttpServer;
-use meilisearch_http::{Opt, create_app, setup_meilisearch};
+use meilisearch_http::{create_app, setup_meilisearch, Opt};
 use meilisearch_lib::MeiliSearch;
 use structopt::StructOpt;
 
@@ -23,7 +23,6 @@ fn setup(opt: &Opt) -> anyhow::Result<()> {
 
     log_builder.init();
 
-
     Ok(())
 }
 
@@ -36,7 +35,9 @@ async fn main() -> anyhow::Result<()> {
     match opt.env.as_ref() {
         "production" => {
             if opt.master_key.is_none() {
-                anyhow::bail!("In production mode, the environment variable MEILI_MASTER_KEY is mandatory")
+                anyhow::bail!(
+                    "In production mode, the environment variable MEILI_MASTER_KEY is mandatory"
+                )
             }
         }
         "development" => (),

meilisearch-http/src/option.rs

@@ -1,16 +1,16 @@
+use std::fs;
 use std::io::{BufReader, Read};
 use std::path::PathBuf;
 use std::sync::Arc;
-use std::fs;
 
 use byte_unit::Byte;
+use meilisearch_lib::options::IndexerOpts;
 use rustls::internal::pemfile::{certs, pkcs8_private_keys, rsa_private_keys};
 use rustls::{
     AllowAnyAnonymousOrAuthenticatedClient, AllowAnyAuthenticatedClient, NoClientAuth,
     RootCertStore,
 };
 use structopt::StructOpt;
-use meilisearch_lib::options::IndexerOpts;
 
 const POSSIBLE_ENV: [&str; 2] = ["development", "production"];
 
@@ -173,24 +173,30 @@ impl Opt {
 }
 
 fn load_certs(filename: PathBuf) -> anyhow::Result<Vec<rustls::Certificate>> {
-    let certfile = fs::File::open(filename).map_err(|_| anyhow::anyhow!("cannot open certificate file"))?;
+    let certfile =
+        fs::File::open(filename).map_err(|_| anyhow::anyhow!("cannot open certificate file"))?;
     let mut reader = BufReader::new(certfile);
-    Ok(certs(&mut reader).map_err(|_| anyhow::anyhow!("cannot read certificate file"))?)
+    certs(&mut reader).map_err(|_| anyhow::anyhow!("cannot read certificate file"))
 }
 
 fn load_private_key(filename: PathBuf) -> anyhow::Result<rustls::PrivateKey> {
     let rsa_keys = {
-        let keyfile =
-            fs::File::open(filename.clone()).map_err(|_| anyhow::anyhow!("cannot open private key file"))?;
+        let keyfile = fs::File::open(filename.clone())
+            .map_err(|_| anyhow::anyhow!("cannot open private key file"))?;
         let mut reader = BufReader::new(keyfile);
-        rsa_private_keys(&mut reader).map_err(|_| anyhow::anyhow!("file contains invalid rsa private key"))?
+        rsa_private_keys(&mut reader)
+            .map_err(|_| anyhow::anyhow!("file contains invalid rsa private key"))?
     };
 
     let pkcs8_keys = {
-        let keyfile = fs::File::open(filename).map_err(|_| anyhow::anyhow!("cannot open private key file"))?;
+        let keyfile = fs::File::open(filename)
+            .map_err(|_| anyhow::anyhow!("cannot open private key file"))?;
         let mut reader = BufReader::new(keyfile);
-        pkcs8_private_keys(&mut reader)
-            .map_err(|_| anyhow::anyhow!("file contains invalid pkcs8 private key (encrypted keys not supported)"))?
+        pkcs8_private_keys(&mut reader).map_err(|_| {
+            anyhow::anyhow!(
+                "file contains invalid pkcs8 private key (encrypted keys not supported)"
+            )
+        })?
     };
 
     // prefer to load pkcs8 keys

meilisearch-http/src/routes/dump.rs

@@ -11,7 +11,9 @@ pub fn configure(cfg: &mut web::ServiceConfig) {
         .service(web::resource("/{dump_uid}/status").route(web::get().to(get_dump_status)));
 }
 
-pub async fn create_dump(meilisearch: GuardedData<Private, MeiliSearch>) -> Result<HttpResponse, ResponseError> {
+pub async fn create_dump(
+    meilisearch: GuardedData<Private, MeiliSearch>,
+) -> Result<HttpResponse, ResponseError> {
     let res = meilisearch.create_dump().await?;
 
     debug!("returns: {:?}", res);

meilisearch-http/src/routes/indexes/documents.rs

@@ -1,11 +1,11 @@
 use actix_web::error::PayloadError;
-use actix_web::{web, HttpResponse};
 use actix_web::web::Bytes;
+use actix_web::{web, HttpResponse};
 use futures::{Stream, StreamExt};
 use log::debug;
-use meilisearch_lib::MeiliSearch;
 use meilisearch_lib::index_controller::{DocumentAdditionFormat, Update};
 use meilisearch_lib::milli::update::IndexDocumentsMethod;
+use meilisearch_lib::MeiliSearch;
 use serde::Deserialize;
 use serde_json::Value;
 use tokio::sync::mpsc;
@@ -38,7 +38,7 @@ guard_content_type!(guard_json, "application/json");
 */
 
 /// This is required because Payload is not Sync nor Send
-fn payload_to_stream(mut payload: Payload) -> impl Stream<Item=Result<Bytes, PayloadError>> {
+fn payload_to_stream(mut payload: Payload) -> impl Stream<Item = Result<Bytes, PayloadError>> {
     let (snd, recv) = mpsc::channel(1);
     tokio::task::spawn_local(async move {
         while let Some(data) = payload.next().await {
@@ -104,9 +104,14 @@ pub async fn delete_document(
     meilisearch: GuardedData<Private, MeiliSearch>,
     path: web::Path<DocumentParam>,
 ) -> Result<HttpResponse, ResponseError> {
-    let DocumentParam { document_id, index_uid } = path.into_inner();
+    let DocumentParam {
+        document_id,
+        index_uid,
+    } = path.into_inner();
     let update = Update::DeleteDocuments(vec![document_id]);
-    let update_status = meilisearch.register_update(index_uid, update, false).await?;
+    let update_status = meilisearch
+        .register_update(index_uid, update, false)
+        .await?;
     debug!("returns: {:?}", update_status);
     Ok(HttpResponse::Accepted().json(serde_json::json!({ "updateId": update_status.id() })))
 }
@@ -216,7 +221,9 @@ pub async fn delete_documents(
         .collect();
 
     let update = Update::DeleteDocuments(ids);
-    let update_status = meilisearch.register_update(path.into_inner().index_uid, update, false).await?;
+    let update_status = meilisearch
+        .register_update(path.into_inner().index_uid, update, false)
+        .await?;
     debug!("returns: {:?}", update_status);
     Ok(HttpResponse::Accepted().json(serde_json::json!({ "updateId": update_status.id() })))
 }
@@ -226,7 +233,9 @@ pub async fn clear_all_documents(
     path: web::Path<IndexParam>,
 ) -> Result<HttpResponse, ResponseError> {
     let update = Update::ClearDocuments;
-    let update_status = meilisearch.register_update(path.into_inner().index_uid, update, false).await?;
+    let update_status = meilisearch
+        .register_update(path.into_inner().index_uid, update, false)
+        .await?;
     debug!("returns: {:?}", update_status);
     Ok(HttpResponse::Accepted().json(serde_json::json!({ "updateId": update_status.id() })))
 }

meilisearch-http/src/routes/indexes/mod.rs

@@ -1,8 +1,8 @@
 use actix_web::{web, HttpResponse};
 use chrono::{DateTime, Utc};
 use log::debug;
-use meilisearch_lib::MeiliSearch;
 use meilisearch_lib::index_controller::IndexSettings;
+use meilisearch_lib::MeiliSearch;
 use serde::{Deserialize, Serialize};
 
 use crate::error::ResponseError;
@@ -36,7 +36,9 @@ pub fn configure(cfg: &mut web::ServiceConfig) {
     );
 }
 
-pub async fn list_indexes(data: GuardedData<Private, MeiliSearch>) -> Result<HttpResponse, ResponseError> {
+pub async fn list_indexes(
+    data: GuardedData<Private, MeiliSearch>,
+) -> Result<HttpResponse, ResponseError> {
     let indexes = data.list_indexes().await?;
     debug!("returns: {:?}", indexes);
     Ok(HttpResponse::Ok().json(indexes))

meilisearch-http/src/routes/indexes/settings.rs

@@ -1,12 +1,12 @@
 use log::debug;
 
-use actix_web::{HttpResponse, web};
-use meilisearch_lib::MeiliSearch;
+use actix_web::{web, HttpResponse};
 use meilisearch_lib::index::{Settings, Unchecked};
 use meilisearch_lib::index_controller::Update;
+use meilisearch_lib::MeiliSearch;
 
-use crate::extractors::authentication::{policies::*, GuardedData};
 use crate::error::ResponseError;
+use crate::extractors::authentication::{policies::*, GuardedData};
 
 #[macro_export]
 macro_rules! make_setting_route {

meilisearch-http/src/routes/indexes/updates.rs

@@ -53,7 +53,9 @@ pub async fn get_all_updates_status(
     meilisearch: GuardedData<Private, MeiliSearch>,
     path: web::Path<IndexParam>,
 ) -> Result<HttpResponse, ResponseError> {
-    let metas = meilisearch.all_update_status(path.into_inner().index_uid).await?;
+    let metas = meilisearch
+        .all_update_status(path.into_inner().index_uid)
+        .await?;
     let metas = metas
         .into_iter()
         .map(UpdateStatusResponse::from)

meilisearch-http/src/routes/mod.rs

@@ -6,8 +6,8 @@ use log::debug;
 use meilisearch_lib::index_controller::updates::status::{UpdateResult, UpdateStatus};
 use serde::{Deserialize, Serialize};
 
-use meilisearch_lib::{MeiliSearch, Update};
 use meilisearch_lib::index::{Settings, Unchecked};
+use meilisearch_lib::{MeiliSearch, Update};
 
 use crate::error::ResponseError;
 use crate::extractors::authentication::{policies::*, GuardedData};
@@ -52,7 +52,7 @@ impl From<&UpdateStatus> for UpdateType {
     fn from(other: &UpdateStatus) -> Self {
         use meilisearch_lib::milli::update::IndexDocumentsMethod::*;
         match other.meta() {
-            Update::DocumentAddition{ method, ..  } => {
+            Update::DocumentAddition { method, .. } => {
                 let number = match other {
                     UpdateStatus::Processed(processed) => match processed.success {
                         UpdateResult::DocumentsAddition(ref addition) => {
@@ -233,7 +233,9 @@ pub async fn running() -> HttpResponse {
     HttpResponse::Ok().json(serde_json::json!({ "status": "MeiliSearch is running" }))
 }
 
-async fn get_stats(meilisearch: GuardedData<Private, MeiliSearch>) -> Result<HttpResponse, ResponseError> {
+async fn get_stats(
+    meilisearch: GuardedData<Private, MeiliSearch>,
+) -> Result<HttpResponse, ResponseError> {
     let response = meilisearch.get_all_stats().await?;
 
     debug!("returns: {:?}", response);