src/export/profiles.rs

@@ -6,75 +6,65 @@ pub trait ExportProfile {
   fn rules(&self) -> Vec<Box<dyn Rule>>;
 }
 
-/// Implements [`ExportProfile`] for a unit struct with a static name and rule
+pub struct CurseForgeProfile;
-/// list.
+pub struct ModrinthProfile;
-///
+pub struct ServerPackProfile;
-/// Each rule entry is an expression evaluated as
-/// `Box::new(super::rules::<expr>)`, supporting both bare unit struct names and
-/// constructor calls with arguments.
-///
-/// # Example
-///
-/// ```ignore
-/// export_profile! {
-///     MyProfile => "my-profile" {
-///         SomeRule,
-///         AnotherRule::new("arg"),
-///     }
-/// }
-/// ```
-macro_rules! export_profile {
-  ($struct:ident => $name:literal { $($rule:expr),* $(,)? }) => {
-    pub struct $struct;
 
-    impl ExportProfile for $struct {
+impl ExportProfile for CurseForgeProfile {
-      fn name(&self) -> &'static str {
+  fn name(&self) -> &'static str {
-        $name
+    "curseforge"
-      }
+  }
 
-      fn rules(&self) -> Vec<Box<dyn Rule>> {
+  fn rules(&self) -> Vec<Box<dyn Rule>> {
-        use super::rules::*;
+    vec![
-        vec![
+      Box::new(super::rules::CopyProjectFilesRule),
-          $(Box::new($rule)),*
+      Box::new(super::rules::FilterByPlatformRule),
-        ]
+      Box::new(super::rules::MissingProjectsAsOverridesRule::new(
-      }
+        "curseforge",
-    }
+      )),
-  };
+      Box::new(super::rules::CopyOverridesRule),
-}
+      Box::new(super::rules::CopyClientOverridesRule),
-
+      Box::new(super::rules::FilterServerOnlyRule),
-export_profile! {
+      Box::new(super::rules::GenerateManifestRule::curseforge()),
-  CurseForgeProfile => "curseforge" {
+      Box::new(super::rules::FilterNonRedistributableRule),
-    CopyProjectFilesRule,
+      Box::new(super::rules::TextReplacementRule),
-    FilterByPlatformRule,
+    ]
-    MissingProjectsAsOverridesRule::new("curseforge"),
-    CopyOverridesRule,
-    CopyClientOverridesRule,
-    FilterServerOnlyRule,
-    GenerateManifestRule::curseforge(),
-    FilterNonRedistributableRule,
-    TextReplacementRule
   }
 }
 
-export_profile! {
+impl ExportProfile for ModrinthProfile {
-  ModrinthProfile => "modrinth" {
+  fn name(&self) -> &'static str {
-    CopyProjectFilesRule,
+    "modrinth"
-    FilterByPlatformRule,
+  }
-    MissingProjectsAsOverridesRule::new("modrinth"),
+
-    CopyOverridesRule,
+  fn rules(&self) -> Vec<Box<dyn Rule>> {
-    CopyClientOverridesRule,
+    vec![
-    FilterServerOnlyRule,
+      Box::new(super::rules::CopyProjectFilesRule),
-    GenerateManifestRule::modrinth(),
+      Box::new(super::rules::FilterByPlatformRule),
-    TextReplacementRule
+      Box::new(super::rules::MissingProjectsAsOverridesRule::new(
+        "modrinth",
+      )),
+      Box::new(super::rules::CopyOverridesRule),
+      Box::new(super::rules::CopyClientOverridesRule),
+      Box::new(super::rules::FilterServerOnlyRule),
+      Box::new(super::rules::GenerateManifestRule::modrinth()),
+      Box::new(super::rules::TextReplacementRule),
+    ]
   }
 }
 
-export_profile! {
+impl ExportProfile for ServerPackProfile {
-  ServerPackProfile => "serverpack" {
+  fn name(&self) -> &'static str {
-    CopyProjectFilesRule,
+    "serverpack"
-    CopyServerOverridesRule,
+  }
-    FilterClientOnlyRule,
+
-    TextReplacementRule
+  fn rules(&self) -> Vec<Box<dyn Rule>> {
+    vec![
+      Box::new(super::rules::CopyProjectFilesRule),
+      Box::new(super::rules::CopyServerOverridesRule),
+      Box::new(super::rules::FilterClientOnlyRule),
+      Box::new(super::rules::TextReplacementRule),
+    ]
   }
 }
 

src/model/lockfile.rs

@@ -578,53 +578,6 @@ pub struct LockFile {
   pub lockfile_version: u32,
 }
 
-impl LockFile {
-  pub fn get_project(&self, pakku_id: &str) -> Option<&Project> {
-    self
-      .projects
-      .iter()
-      .find(|p| p.pakku_id.as_deref() == Some(pakku_id))
-  }
-
-  pub fn get_loader_names(&self) -> Vec<String> {
-    self.loaders.keys().cloned().collect()
-  }
-
-  pub fn remove_project(&mut self, pakku_id: &str) -> Option<Project> {
-    if let Some(pos) = self
-      .projects
-      .iter()
-      .position(|p| p.pakku_id.as_deref() == Some(pakku_id))
-    {
-      Some(self.projects.remove(pos))
-    } else {
-      None
-    }
-  }
-
-  pub fn find_project(&self, pakku_id: &str) -> Option<&Project> {
-    self.get_project(pakku_id)
-  }
-
-  pub fn find_project_mut(&mut self, pakku_id: &str) -> Option<&mut Project> {
-    self
-      .projects
-      .iter_mut()
-      .find(|p| p.pakku_id.as_deref() == Some(pakku_id))
-  }
-
-  pub fn find_project_by_platform_id(
-    &self,
-    platform: &str,
-    id: &str,
-  ) -> Option<&Project> {
-    self
-      .projects
-      .iter()
-      .find(|p| p.id.get(platform).is_some_and(|pid| pid == id))
-  }
-}
-
 impl LockFile {
   pub fn load<P: AsRef<Path>>(path: P) -> Result<Self> {
     Self::load_with_validation(path, true)
@@ -767,4 +720,52 @@ impl LockFile {
     self.projects.push(project);
     self.projects.sort_by_key(super::project::Project::get_name);
   }
+
+  pub fn get_project(&self, pakku_id: &str) -> Option<&Project> {
+    self
+      .projects
+      .iter()
+      .find(|p| p.pakku_id.as_deref() == Some(pakku_id))
+  }
+
+  pub fn get_loader_names(&self) -> Vec<String> {
+    self.loaders.keys().cloned().collect()
+  }
+
+  pub fn remove_project(&mut self, pakku_id: &str) -> Option<Project> {
+    if let Some(pos) = self
+      .projects
+      .iter()
+      .position(|p| p.pakku_id.as_deref() == Some(pakku_id))
+    {
+      Some(self.projects.remove(pos))
+    } else {
+      None
+    }
+  }
+
+  pub fn find_project(&self, pakku_id: &str) -> Option<&Project> {
+    self
+      .projects
+      .iter()
+      .find(|p| p.pakku_id.as_deref() == Some(pakku_id))
+  }
+
+  pub fn find_project_mut(&mut self, pakku_id: &str) -> Option<&mut Project> {
+    self
+      .projects
+      .iter_mut()
+      .find(|p| p.pakku_id.as_deref() == Some(pakku_id))
+  }
+
+  pub fn find_project_by_platform_id(
+    &self,
+    platform: &str,
+    id: &str,
+  ) -> Option<&Project> {
+    self
+      .projects
+      .iter()
+      .find(|p| p.id.get(platform).is_some_and(|pid| pid == id))
+  }
 }

src/rate_limiter.rs

@@ -72,29 +72,30 @@ impl RateLimiter {
 
     let interval = Duration::from_secs(60) / rate.max(1);
 
-    loop {
+    let mut inner = self.inner.lock().await;
-      let mut inner = self.inner.lock().await;
+    let now = Instant::now();
-      let now = Instant::now();
+    let platform_requests =
-      let platform_requests =
+      inner.requests.entry(platform.to_string()).or_default();
-        inner.requests.entry(platform.to_string()).or_default();
 
-      platform_requests
+    platform_requests
-        .retain(|t| now.duration_since(*t) < Duration::from_secs(60));
+      .retain(|t| now.duration_since(*t) < Duration::from_secs(60));
 
-      if platform_requests.len() >= burst as usize
+    if platform_requests.len() >= burst as usize
-        && let Some(oldest) = platform_requests.first()
+      && let Some(oldest) = platform_requests.first()
-      {
+    {
-        let wait_time = interval.saturating_sub(now.duration_since(*oldest));
+      let wait_time = interval.saturating_sub(now.duration_since(*oldest));
-        if wait_time > Duration::ZERO {
+      if wait_time > Duration::ZERO {
-          drop(inner);
+        drop(inner);
-          tokio::time::sleep(wait_time).await;
+        tokio::time::sleep(wait_time).await;
-          continue;
-        }
       }
-
-      platform_requests.push(Instant::now());
-      return Ok(());
     }
+
+    let mut inner = self.inner.lock().await;
+    let platform_requests =
+      inner.requests.entry(platform.to_string()).or_default();
+    platform_requests.push(Instant::now());
+
+    Ok(())
   }
 
   pub async fn wait_for(&self, platform: &str) {