Run cargo fmt

Author: IThundxr

apps/labrinth/src/models/v3/projects.rs

@@ -928,7 +928,15 @@ impl VersionType {
 }
 
 #[derive(
-    Serialize, Deserialize, Copy, Clone, Debug, PartialEq, Eq, sqlx::Type, utoipa::ToSchema,
+    Serialize,
+    Deserialize,
+    Copy,
+    Clone,
+    Debug,
+    PartialEq,
+    Eq,
+    sqlx::Type,
+    utoipa::ToSchema,
 )]
 #[sqlx(type_name = "varchar", rename_all = "lowercase")]
 #[serde(rename_all = "lowercase")]

apps/labrinth/src/search/backend/elasticsearch/mod.rs

@@ -263,9 +263,18 @@ static ELASTICSEARCH_PROPERTIES: LazyLock<serde_json::Map<String, Value>> =
             ("license".to_string(), json!({ "type": "keyword" })),
             ("loaders".to_string(), json!({ "type": "keyword" })),
             ("color".to_string(), json!({ "type": "long" })),
-            ("required_dependencies".to_string(), json!({ "type": "keyword" })),
-            ("optional_dependencies".to_string(), json!({ "type": "keyword" })),
-            ("incompatibilities".to_string(), json!({ "type": "keyword" })),
+            (
+                "required_dependencies".to_string(),
+                json!({ "type": "keyword" }),
+            ),
+            (
+                "optional_dependencies".to_string(),
+                json!({ "type": "keyword" }),
+            ),
+            (
+                "incompatibilities".to_string(),
+                json!({ "type": "keyword" }),
+            ),
             ("environment".to_string(), json!({ "type": "keyword" })),
             ("mrpack_loaders".to_string(), json!({ "type": "keyword" })),
             (

apps/labrinth/src/search/indexing.rs

@@ -21,7 +21,7 @@ use crate::database::models::{
 use crate::database::redis::RedisPool;
 use crate::models::exp;
 use crate::models::ids::{ProjectId, VersionId};
-use crate::models::projects::{from_duplicate_version_fields, DependencyType};
+use crate::models::projects::{DependencyType, from_duplicate_version_fields};
 use crate::models::v2::projects::LegacyProject;
 use crate::routes::v2_reroute;
 use crate::search::{Dependencies, Dependency, UploadSearchProject};
@@ -639,7 +639,7 @@ async fn index_versions(
     // Version (Project A v1.0.0, vID: 400) has a (required) dependency on the version (Project B v2.0.0, vID: 500) from the Project (Project B, pID: 2)
     // ~ @ithundxr
     let dependencies: DashMap<DBVersionId, Dependencies> = sqlx::query!(
-            "
+        "
             SELECT
                 d.dependent_id as \"dependent_version_id: DBVersionId\",
                 d.mod_dependency_id as \"dependency_project_id: DBProjectId\",
@@ -649,28 +649,28 @@ async fn index_versions(
             INNER JOIN mods m ON m.id = d.mod_dependency_id
             WHERE dependent_id = ANY($1) AND dependency_type != 'embedded'
             ",
-            &all_version_ids
-        )
-        .fetch(pool)
-        .try_fold(
-            DashMap::new(),
-            |acc: DashMap<DBVersionId, Dependencies>, m| {
-                if let Some(dependency_project_id) = m.dependency_project_id {
-                    let dependency = Dependency {
-                        project: ProjectId::from(dependency_project_id),
-                        version: m.dependency_version_id.map(VersionId::from),
-                    };
-
-                    acc.entry(m.dependent_version_id)
-                        .or_default()
-                        .add_dependency(m.dependency_type, dependency);
-                }
+        &all_version_ids
+    )
+    .fetch(pool)
+    .try_fold(
+        DashMap::new(),
+        |acc: DashMap<DBVersionId, Dependencies>, m| {
+            if let Some(dependency_project_id) = m.dependency_project_id {
+                let dependency = Dependency {
+                    project: ProjectId::from(dependency_project_id),
+                    version: m.dependency_version_id.map(VersionId::from),
+                };
 
-                async move { Ok(acc) }
+                acc.entry(m.dependent_version_id)
+                    .or_default()
+                    .add_dependency(m.dependency_type, dependency);
             }
-        )
-        .await
-        .wrap_err("failed to fetch dependencies")?;
+
+            async move { Ok(acc) }
+        },
+    )
+    .await
+    .wrap_err("failed to fetch dependencies")?;
 
     // Convert to partial versions
     let mut res_versions: HashMap<DBProjectId, Vec<PartialVersion>> =

apps/labrinth/src/search/mod.rs

@@ -2,20 +2,20 @@ use crate::database::redis::RedisPool;
 use crate::models::exp;
 use crate::models::exp::minecraft::JavaServerPing;
 use crate::models::ids::{ProjectId, VersionId};
+use crate::models::projects::DependencyType;
 use crate::queue::server_ping;
 use crate::routes::ApiError;
 use crate::{database::PgPool, env::ENV};
 use ariadne::ids::base62_impl::parse_base62;
 use async_trait::async_trait;
 use chrono::{DateTime, Utc};
+use serde::de::{Error, Visitor};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde_json::Value;
-use std::{collections::HashMap, str::FromStr};
 use std::fmt::Formatter;
-use serde::de::{Error, Visitor};
+use std::{collections::HashMap, str::FromStr};
 use thiserror::Error;
 use utoipa::ToSchema;
-use crate::models::projects::DependencyType;
 
 pub mod backend;
 pub mod indexing;
@@ -235,7 +235,7 @@ pub struct Dependency {
 impl Serialize for Dependency {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
-        S: Serializer
+        S: Serializer,
     {
         let s = match self.version {
             Some(version) => format!("{}:{}", self.project, version),
@@ -248,15 +248,16 @@ impl Serialize for Dependency {
 impl<'de> Deserialize<'de> for Dependency {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
-        D: Deserializer<'de>
+        D: Deserializer<'de>,
     {
         struct DependencyVisitor;
 
         impl<'de> Visitor<'de> for DependencyVisitor {
             type Value = Dependency;
 
             fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
-                formatter.write_str("a string in the format 'project[:version]'")
+                formatter
+                    .write_str("a string in the format 'project[:version]'")
             }
 
             fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
@@ -265,12 +266,14 @@ impl<'de> Deserialize<'de> for Dependency {
             {
                 let mut parts = v.splitn(2, ":");
 
-                let project = parts.next()
-                    .and_then(|x|  parse_base62(x).ok())
+                let project = parts
+                    .next()
+                    .and_then(|x| parse_base62(x).ok())
                     .map(ProjectId)
                     .ok_or_else(|| E::custom("ProjectId is missing"))?;
-                let version = parts.next()
-                    .and_then(|x|  parse_base62(x).ok())
+                let version = parts
+                    .next()
+                    .and_then(|x| parse_base62(x).ok())
                     .map(VersionId);
 
                 Ok(Dependency { project, version })
@@ -292,7 +295,11 @@ pub struct Dependencies {
 }
 
 impl Dependencies {
-    pub fn add_dependency(&mut self, dependency_type: DependencyType, dep: Dependency) {
+    pub fn add_dependency(
+        &mut self,
+        dependency_type: DependencyType,
+        dep: Dependency,
+    ) {
         match dependency_type {
             DependencyType::Required => self.required_dependencies.push(dep),
             DependencyType::Optional => self.optional_dependencies.push(dep),
@@ -470,7 +477,8 @@ mod tests {
         };
 
         let serialized = serde_json::to_string(&dependency).unwrap();
-        let deserialized: Dependency = serde_json::from_str(&serialized).unwrap();
+        let deserialized: Dependency =
+            serde_json::from_str(&serialized).unwrap();
 
         assert_eq!(dependency.project, deserialized.project);
         assert_eq!(dependency.version, deserialized.version);
@@ -484,9 +492,10 @@ mod tests {
         };
 
         let serialized = serde_json::to_string(&dependency).unwrap();
-        let deserialized: Dependency = serde_json::from_str(&serialized).unwrap();
+        let deserialized: Dependency =
+            serde_json::from_str(&serialized).unwrap();
 
         assert_eq!(dependency.project, deserialized.project);
         assert_eq!(dependency.version, deserialized.version);
     }
-}
+}