fix: revert SupportFn type change

Author: brianheineman

postgresql_archive/Cargo.toml

@@ -53,8 +53,8 @@ default = [
 ]
 blocking = ["dep:tokio"]
 github = [
-    "dep:target-triple",
     "dep:serde_json",
+    "dep:target-triple",
 ]
 indicatif = [
     "dep:tracing-indicatif"

postgresql_archive/src/configuration/custom/matcher.rs

@@ -1,39 +1,37 @@
 use semver::Version;
 
-/// Matcher for PostgreSQL binaries from custom GitHub release repositories
-/// following the same pattern as <https://github.com/theseus-rs/postgresql-binaries>
+/// Matcher for PostgreSQL binaries from custom GitHub release repositories following the same
+/// pattern as <https://github.com/theseus-rs/postgresql-binaries>
 ///
 /// # Errors
 /// * If the asset matcher fails.
-/// TODO: support more custom settings
 pub fn matcher(_url: &str, name: &str, version: &Version) -> crate::Result<bool> {
     let target = target_triple::TARGET;
+    // TODO: consider relaxing the version format to allow for more flexibility in where the version
+    //       and target appear in the filename.
     let expected_name = format!("postgresql-{version}-{target}.tar.gz");
     Ok(name == expected_name)
 }
 
 #[cfg(test)]
 mod tests {
-    use std::sync::Arc;
-
     use super::*;
-    use crate::{
-        Result,
-        matcher::{self, registry::SupportsFn},
-    };
+    use crate::{Result, matcher};
+
+    const TEST_URL: &str = "https://github.com/owner/repo";
 
     #[test]
     fn test_register_custom_repo() -> Result<()> {
-        let custom_url = "https://github.com/Owner/Repo";
-        let wrapped_url = Arc::new(custom_url.to_string());
-        let supports_fn: SupportsFn = Box::new(move |url| Ok(url == wrapped_url.as_str()));
+        #[expect(clippy::unnecessary_wraps)]
+        fn supports_fn(url: &str) -> Result<bool> {
+            Ok(url == TEST_URL)
+        }
         matcher::registry::register(supports_fn, matcher)?;
 
-        let matcher = matcher::registry::get(custom_url)?;
+        let matcher = matcher::registry::get(TEST_URL)?;
         let version = Version::new(16, 3, 0);
         let expected_name = format!("postgresql-{}-{}.tar.gz", version, target_triple::TARGET);
         assert!(matcher("", &expected_name, &version)?);
-
         Ok(())
     }
 }

postgresql_archive/src/configuration/mod.rs

@@ -1,5 +1,5 @@
+pub mod custom;
 #[cfg(feature = "theseus")]
 pub mod theseus;
 #[cfg(feature = "zonky")]
 pub mod zonky;
-pub mod custom;

postgresql_archive/src/matcher/registry.rs

@@ -10,7 +10,7 @@ use std::sync::{Arc, LazyLock, Mutex, RwLock};
 static REGISTRY: LazyLock<Arc<Mutex<MatchersRegistry>>> =
     LazyLock::new(|| Arc::new(Mutex::new(MatchersRegistry::default())));
 
-pub type SupportsFn = Box<dyn Fn(&str) -> Result<bool> + Send + Sync + 'static>;
+pub type SupportsFn = fn(&str) -> Result<bool>;
 pub type MatcherFn = fn(&str, &str, &Version) -> Result<bool>;
 
 /// Singleton struct to store matchers
@@ -66,9 +66,9 @@ impl Default for MatchersRegistry {
     fn default() -> Self {
         let mut registry = Self::new();
         #[cfg(feature = "theseus")]
-        registry.register(Box::new(|url| Ok(url == theseus::URL)), theseus::matcher);
+        registry.register(|url| Ok(url == theseus::URL), theseus::matcher);
         #[cfg(feature = "zonky")]
-        registry.register(Box::new(|url| Ok(url == zonky::URL)), zonky::matcher);
+        registry.register(|url| Ok(url == zonky::URL), zonky::matcher);
         registry
     }
 }
@@ -78,14 +78,12 @@ impl Default for MatchersRegistry {
 ///
 /// # Errors
 /// * If the registry is poisoned.
-pub fn register<F>(supports_fn: F, matcher_fn: MatcherFn) -> Result<()>
-where
-    F: Fn(&str) -> Result<bool> + Send + Sync + 'static,
-{
+pub fn register(supports_fn: SupportsFn, matcher_fn: MatcherFn) -> Result<()>
+where {
     let mut registry = REGISTRY
         .lock()
         .map_err(|error| PoisonedLock(error.to_string()))?;
-    registry.register(Box::new(supports_fn), matcher_fn);
+    registry.register(supports_fn, matcher_fn);
     Ok(())
 }
 

postgresql_embedded/build/bundle.rs

@@ -2,15 +2,13 @@
 
 use anyhow::Result;
 use postgresql_archive::configuration::custom;
-use postgresql_archive::matcher::registry::SupportsFn;
 use postgresql_archive::repository::github::repository::GitHub;
 use postgresql_archive::{VersionReq, matcher};
 use postgresql_archive::{get_archive, repository};
 use std::fs::File;
 use std::io::Write;
 use std::path::PathBuf;
 use std::str::FromStr;
-use std::sync::Arc;
 use std::{env, fs};
 use url::Url;
 
@@ -25,13 +23,11 @@ pub(crate) async fn stage_postgresql_archive() -> Result<()> {
     let default_releases_url = String::new();
 
     let releases_url = match env::var("POSTGRESQL_RELEASES_URL") {
-        Ok(custom_url) => {
-            if !custom_url.is_empty() {
-                register_github_repository(&custom_url)?;
-            }
+        Ok(custom_url) if !default_releases_url.is_empty() => {
+            register_github_repository()?;
             custom_url
         }
-        Err(_) => default_releases_url,
+        _ => default_releases_url,
     };
     println!("PostgreSQL releases URL: {releases_url}");
     let postgres_version_req = env::var("POSTGRESQL_VERSION").unwrap_or("*".to_string());
@@ -63,21 +59,14 @@ pub(crate) async fn stage_postgresql_archive() -> Result<()> {
     Ok(())
 }
 
-fn register_github_repository(custom_url: &str) -> Result<()> {
-    repository::registry::register(
-        |url| {
-            let parsed_url = Url::parse(url)?;
-            let host = parsed_url.host_str().unwrap_or_default();
-            Ok(host.ends_with("github.com"))
-        },
-        Box::new(GitHub::new),
-    )?;
-
-    // make custom_url as Send + Sync + 'static
-    let custom_url = Arc::new(custom_url.to_string());
-    let supports_fn: SupportsFn = Box::new(move |url| Ok(url == custom_url.as_str()));
-    // register the matcher
-    matcher::registry::register(supports_fn, custom::matcher::matcher)?;
+fn supports_github_url(url: &str) -> postgresql_archive::Result<bool> {
+    let parsed_url = Url::parse(url)?;
+    let host = parsed_url.host_str().unwrap_or_default();
+    Ok(host.ends_with("github.com"))
+}
 
+fn register_github_repository() -> Result<()> {
+    repository::registry::register(supports_github_url, Box::new(GitHub::new))?;
+    matcher::registry::register(supports_github_url, custom::matcher::matcher)?;
     Ok(())
 }