refactor: extract duplicated helpers and reduce code repetition

- main.rs: Extract unpack_sdist_for_build() and StripOption shared struct
  to eliminate duplicated sdist-then-build and --strip arg definitions
- build_context/mod.rs: Unify build_cffi_wheel/build_uniffi_wheel into
  shared build_cdylib_wheel() pipeline
- metadata.rs: Extract split_contacts() for duplicated author/maintainer
  processing
- auditwheel: Make is_dynamic_linker() pub(crate), extract run_patchelf()
- binding_generator: Extract cdylib_filename() shared helper
- module_writer: Extract file_permission_mode() helper
- pyproject_toml.rs: Extract CIConfigOverrides with serde(flatten)
- source_distribution: Extract resolve_workspace_dep_entries()

Author: messense

src/auditwheel/audit.rs

@@ -20,8 +20,13 @@ use tracing::debug;
 static IS_LIBPYTHON: Lazy<Regex> =
     Lazy::new(|| Regex::new(r"^libpython3\.\d+m?u?t?\.so\.\d+\.\d+$").unwrap());
 
-fn is_dynamic_linker(name: &str) -> bool {
-    name.starts_with("ld-linux") || name == "ld64.so.2" || name == "ld64.so.1"
+/// Returns `true` if the given shared-library name is a dynamic linker
+/// (e.g. `ld-linux-x86-64.so.2`, `ld64.so.2`, `ld-musl-*.so.1`).
+pub(crate) fn is_dynamic_linker(name: &str) -> bool {
+    name.starts_with("ld-linux")
+        || name == "ld64.so.2"
+        || name == "ld64.so.1"
+        || name.starts_with("ld-musl")
 }
 
 /// Error raised during auditing an elf file for manylinux/musllinux compatibility

src/auditwheel/patchelf.rs

@@ -5,13 +5,27 @@ use std::process::Command;
 
 static MISSING_PATCHELF_ERROR: &str = "Failed to execute 'patchelf', did you install it? Hint: Try `pip install maturin[patchelf]` (or just `pip install patchelf`)";
 
-/// Verify patchelf version
-pub fn verify_patchelf() -> Result<()> {
+/// Run a patchelf command with the given arguments.
+///
+/// Returns `Ok(stdout)` on success, or an error with the stderr message.
+fn run_patchelf(args: &[&OsStr]) -> Result<Vec<u8>> {
     let output = Command::new("patchelf")
-        .arg("--version")
+        .args(args)
         .output()
         .context(MISSING_PATCHELF_ERROR)?;
-    let version = String::from_utf8(output.stdout)
+    if !output.status.success() {
+        bail!(
+            "patchelf failed: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+    Ok(output.stdout)
+}
+
+/// Verify patchelf version
+pub fn verify_patchelf() -> Result<()> {
+    let stdout = run_patchelf(&[OsStr::new("--version")])?;
+    let version = String::from_utf8(stdout)
         .context("Failed to parse patchelf version")?
         .trim()
         .to_string();
@@ -33,64 +47,42 @@ pub fn replace_needed<O: AsRef<OsStr>, N: AsRef<OsStr>>(
     file: impl AsRef<Path>,
     old_new_pairs: &[(O, N)],
 ) -> Result<()> {
-    let mut cmd = Command::new("patchelf");
+    let mut args: Vec<&OsStr> = Vec::new();
     for (old, new) in old_new_pairs {
-        cmd.arg("--replace-needed").arg(old).arg(new);
-    }
-    cmd.arg(file.as_ref());
-    let output = cmd.output().context(MISSING_PATCHELF_ERROR)?;
-    if !output.status.success() {
-        bail!(
-            "patchelf --replace-needed failed: {}",
-            String::from_utf8_lossy(&output.stderr)
-        );
+        args.push(OsStr::new("--replace-needed"));
+        args.push(old.as_ref());
+        args.push(new.as_ref());
     }
+    args.push(file.as_ref().as_os_str());
+    run_patchelf(&args)?;
     Ok(())
 }
 
 /// Change `SONAME` of a dynamic library
 pub fn set_soname<S: AsRef<OsStr>>(file: impl AsRef<Path>, soname: &S) -> Result<()> {
-    let mut cmd = Command::new("patchelf");
-    cmd.arg("--set-soname").arg(soname).arg(file.as_ref());
-    let output = cmd.output().context(MISSING_PATCHELF_ERROR)?;
-    if !output.status.success() {
-        bail!(
-            "patchelf --set-soname failed: {}",
-            String::from_utf8_lossy(&output.stderr)
-        );
-    }
+    run_patchelf(&[
+        OsStr::new("--set-soname"),
+        soname.as_ref(),
+        file.as_ref().as_os_str(),
+    ])?;
     Ok(())
 }
 
 /// Remove a `RPATH` from executables and libraries
 pub fn remove_rpath(file: impl AsRef<Path>) -> Result<()> {
-    let mut cmd = Command::new("patchelf");
-    cmd.arg("--remove-rpath").arg(file.as_ref());
-    let output = cmd.output().context(MISSING_PATCHELF_ERROR)?;
-    if !output.status.success() {
-        bail!(
-            "patchelf --remove-rpath failed: {}",
-            String::from_utf8_lossy(&output.stderr)
-        );
-    }
+    run_patchelf(&[OsStr::new("--remove-rpath"), file.as_ref().as_os_str()])?;
     Ok(())
 }
 
 /// Change the `RPATH` of executables and libraries
 pub fn set_rpath<S: AsRef<OsStr>>(file: impl AsRef<Path>, rpath: &S) -> Result<()> {
     remove_rpath(&file)?;
-    let mut cmd = Command::new("patchelf");
-    cmd.arg("--force-rpath")
-        .arg("--set-rpath")
-        .arg(rpath)
-        .arg(file.as_ref());
-    let output = cmd.output().context(MISSING_PATCHELF_ERROR)?;
-    if !output.status.success() {
-        bail!(
-            "patchelf --set-rpath failed: {}",
-            String::from_utf8_lossy(&output.stderr)
-        );
-    }
+    run_patchelf(&[
+        OsStr::new("--force-rpath"),
+        OsStr::new("--set-rpath"),
+        rpath.as_ref(),
+        file.as_ref().as_os_str(),
+    ])?;
     Ok(())
 }
 

src/auditwheel/repair.rs

@@ -1,4 +1,4 @@
-use super::audit::AuditWheelError;
+use super::audit::{AuditWheelError, is_dynamic_linker};
 use crate::auditwheel::Policy;
 use anyhow::Result;
 use lddtree::DependencyAnalyzer;
@@ -19,12 +19,8 @@ pub fn find_external_libs(
     let mut ext_libs = Vec::new();
     for (_, lib) in deps.libraries {
         let name = &lib.name;
-        // Skip dynamic linker/loader and white-listed libs
-        if name.starts_with("ld-linux")
-            || name == "ld64.so.2"
-            || name == "ld64.so.1"
-            // musl libc, eg: libc.musl-aarch64.so.1
-            || name.starts_with("ld-musl")
+        // Skip dynamic linker/loader, musl libc, and white-listed libs
+        if is_dynamic_linker(name)
             || name.starts_with("libc.")
             || policy.lib_whitelist.contains(name)
         {

src/binding_generator/cffi_binding.rs

@@ -22,7 +22,6 @@ use crate::PythonInterpreter;
 use crate::archive_source::ArchiveSource;
 use crate::archive_source::GeneratedSourceData;
 use crate::binding_generator::ArtifactTarget;
-use crate::target::Os;
 
 use super::BindingGenerator;
 use super::GeneratorOutput;
@@ -52,11 +51,7 @@ impl<'a> BindingGenerator for CffiBindingGenerator<'a> {
         let cffi_module_file_name = {
             let extension_name = &context.project_layout.extension_name;
             // https://cffi.readthedocs.io/en/stable/embedding.html#issues-about-using-the-so
-            match context.target.target_os() {
-                Os::Macos => format!("lib{extension_name}.dylib"),
-                Os::Windows => format!("{extension_name}.dll"),
-                _ => format!("lib{extension_name}.so"),
-            }
+            super::cdylib_filename(extension_name, context.target.target_os())
         };
         let base_path = if context.project_layout.python_module.is_some() {
             module.join(&context.project_layout.extension_name)

src/binding_generator/mod.rs

@@ -36,6 +36,19 @@ pub use cffi_binding::CffiBindingGenerator;
 pub use pyo3_binding::Pyo3BindingGenerator;
 pub use uniffi_binding::UniFfiBindingGenerator;
 
+use crate::target::Os;
+
+/// Returns the platform-specific cdylib filename for the given library name.
+///
+/// For example, `cdylib_filename("foo", Os::Macos)` returns `"libfoo.dylib"`.
+pub(crate) fn cdylib_filename(name: &str, os: Os) -> String {
+    match os {
+        Os::Macos => format!("lib{name}.dylib"),
+        Os::Windows => format!("{name}.dll"),
+        _ => format!("lib{name}.so"),
+    }
+}
+
 /// A trait to generate the binding files to be included in the built module
 ///
 /// This trait is used to generate the support files necessary to build a python

src/binding_generator/uniffi_binding.rs

@@ -226,11 +226,7 @@ fn generate_uniffi_bindings(
     let cdylib = match cdylib_name {
         // this logic should match with uniffi's expected names, e.g.
         // https://github.com/mozilla/uniffi-rs/blob/86a34083dd18bdd33f420c602b4fad624cc1e404/uniffi_bindgen/src/bindings/python/templates/NamespaceLibraryTemplate.py#L14-L37
-        Some(cdylib_name) => match target_os {
-            Os::Macos => format!("lib{cdylib_name}.dylib"),
-            Os::Windows => format!("{cdylib_name}.dll"),
-            _ => format!("lib{cdylib_name}.so"),
-        },
+        Some(cdylib_name) => super::cdylib_filename(&cdylib_name, target_os),
         None => artifact.file_name().unwrap().to_str().unwrap().to_string(),
     };
 

src/build_context/builder.rs

@@ -238,8 +238,7 @@ impl BuildContextBuilder {
             .unwrap_or_else(|| cargo_metadata.target_directory.clone().into_std_path_buf());
 
         let config_targets = pyproject.and_then(|x| x.targets());
-        let compile_targets =
-            filter_cargo_targets(&cargo_metadata, bridge, config_targets.as_deref())?;
+        let compile_targets = filter_cargo_targets(&cargo_metadata, bridge, config_targets)?;
         if compile_targets.is_empty() {
             bail!(
                 "No Cargo targets to build, please check your bindings configuration in pyproject.toml."

src/build_context/mod.rs

@@ -868,49 +868,50 @@ impl BuildContext {
         Ok(())
     }
 
-    fn write_cffi_wheel(
-        &self,
-        artifact: BuildArtifact,
-        platform_tags: &[PlatformTag],
-        ext_libs: Vec<Library>,
+    /// Shared build pipeline for cdylib-based bindings (CFFI, UniFfi).
+    ///
+    /// Compiles the cdylib, runs auditwheel, resolves platform tags, writes
+    /// the wheel via `write_wheel`, and returns the built wheel metadata.
+    #[allow(clippy::needless_lifetimes)] // false positive
+    fn build_cdylib_wheel<'a, F>(
+        &'a self,
+        make_generator: F,
         sbom_data: &Option<SbomData>,
-        out_dirs: &HashMap<String, PathBuf>,
-    ) -> Result<PathBuf> {
-        let tag = self.get_universal_tag(platform_tags)?;
-
-        let interpreter = self.interpreter.first().ok_or_else(|| {
-            anyhow!("A python interpreter is required for cffi builds but one was not provided")
-        })?;
-        self.write_wheel(
+    ) -> Result<(PathBuf, HashMap<String, PathBuf>)>
+    where
+        F: FnOnce(Rc<tempfile::TempDir>) -> Result<Box<dyn BindingGenerator + 'a>>,
+    {
+        let (artifact, out_dirs) = self.compile_cdylib(None, None)?;
+        let (policy, external_libs) = self.auditwheel(&artifact, &self.platform_tag, None)?;
+        let platform_tags = self.resolve_platform_tags(&policy);
+        let tag = self.get_universal_tag(&platform_tags)?;
+        let wheel_path = self.write_wheel(
             &tag,
             &[&artifact],
-            &[ext_libs],
-            |temp_dir| {
-                Ok(Box::new(
-                    CffiBindingGenerator::new(interpreter, temp_dir)
-                        .context("Failed to initialize Cffi binding generator")?,
-                ))
-            },
+            &[external_libs],
+            make_generator,
             sbom_data,
-            out_dirs,
-        )
+            &out_dirs,
+        )?;
+        Ok((wheel_path, out_dirs))
     }
 
     /// Builds a wheel with cffi bindings
     pub fn build_cffi_wheel(
         &self,
         sbom_data: &Option<SbomData>,
     ) -> Result<Vec<BuiltWheelMetadata>> {
-        let mut wheels = Vec::new();
-        let (artifact, out_dirs) = self.compile_cdylib(None, None)?;
-        let (policy, external_libs) = self.auditwheel(&artifact, &self.platform_tag, None)?;
-        let platform_tags = self.resolve_platform_tags(&policy);
-        let wheel_path = self.write_cffi_wheel(
-            artifact,
-            &platform_tags,
-            external_libs,
+        let interpreter = self.interpreter.first().ok_or_else(|| {
+            anyhow!("A python interpreter is required for cffi builds but one was not provided")
+        })?;
+        let (wheel_path, _) = self.build_cdylib_wheel(
+            |temp_dir| {
+                Ok(Box::new(
+                    CffiBindingGenerator::new(interpreter, temp_dir)
+                        .context("Failed to initialize Cffi binding generator")?,
+                ))
+            },
             sbom_data,
-            &out_dirs,
         )?;
 
         // Warn if cffi isn't specified in the requirements
@@ -927,52 +928,21 @@ impl BuildContext {
         }
 
         eprintln!("📦 Built wheel to {}", wheel_path.display());
-        wheels.push((wheel_path, "py3".to_string()));
-
-        Ok(wheels)
-    }
-
-    fn write_uniffi_wheel(
-        &self,
-        artifact: BuildArtifact,
-        platform_tags: &[PlatformTag],
-        ext_libs: Vec<Library>,
-        sbom_data: &Option<SbomData>,
-        out_dirs: &HashMap<String, PathBuf>,
-    ) -> Result<PathBuf> {
-        let tag = self.get_universal_tag(platform_tags)?;
-
-        self.write_wheel(
-            &tag,
-            &[&artifact],
-            &[ext_libs],
-            |_temp_dir| Ok(Box::new(UniFfiBindingGenerator::default())),
-            sbom_data,
-            out_dirs,
-        )
+        Ok(vec![(wheel_path, "py3".to_string())])
     }
 
     /// Builds a wheel with uniffi bindings
     pub fn build_uniffi_wheel(
         &self,
         sbom_data: &Option<SbomData>,
     ) -> Result<Vec<BuiltWheelMetadata>> {
-        let mut wheels = Vec::new();
-        let (artifact, out_dirs) = self.compile_cdylib(None, None)?;
-        let (policy, external_libs) = self.auditwheel(&artifact, &self.platform_tag, None)?;
-        let platform_tags = self.resolve_platform_tags(&policy);
-        let wheel_path = self.write_uniffi_wheel(
-            artifact,
-            &platform_tags,
-            external_libs,
+        let (wheel_path, _) = self.build_cdylib_wheel(
+            |_temp_dir| Ok(Box::new(UniFfiBindingGenerator::default())),
             sbom_data,
-            &out_dirs,
         )?;
 
         eprintln!("📦 Built wheel to {}", wheel_path.display());
-        wheels.push((wheel_path, "py3".to_string()));
-
-        Ok(wheels)
+        Ok(vec![(wheel_path, "py3".to_string())])
     }
 
     fn write_bin_wheel(