refactor(archiver): yield PathBuf from ArchivableFilesFinder, drop SplFileInfo

Migrate ArchivableFilesFinder off Symfony's SplFileInfo onto Path/PathBuf,
resolving the phar_archiver TODO(phase-b) that required a .map() adapter to
bridge SplFileInfo -> PathBuf.

- ArchivableFilesFinder now yields PathBuf; accept() takes &Path; the exclude
  closure receives &Path and uses Path::canonicalize / is_symlink. The
  SplFileInfo -> PathBuf conversion happens once at the symfony get_iterator
  boundary (get_iterator stays SplFileInfo for cache.rs).
- symfony Finder::filter callback changed to FnMut(&Path) (sole caller is the
  finder).
- PharArchiver passes the finder straight into ArchivableFilesFilter, mirroring
  PHP's new ArchivableFilesFilter($files).
- ZipArchiver consumes PathBuf items, computing the relative path via
  strip_prefix(sources) in place of SplFileInfo::getRelativePathname.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

3 files changed, 35 insertions, 26 deletions

diff --git a/crates/shirabe/src/package/archiver/archivable_files_finder.rs b/crates/shirabe/src/package/archiver/archivable_files_finder.rs
index 09041a3..f88f9b8 100644
--- a/crates/shirabe/src/package/archiver/archivable_files_finder.rs
+++ b/crates/shirabe/src/package/archiver/archivable_files_finder.rs
@@ -5,12 +5,12 @@ use crate::package::archiver::GitExcludeFilter;
 use crate::util::Filesystem;
 use shirabe_external_packages::composer::pcre::Preg;
 use shirabe_external_packages::symfony::component::finder::Finder;
-use shirabe_external_packages::symfony::component::finder::SplFileInfo;
 use shirabe_php_shim::{RuntimeException, preg_quote, realpath};
+use std::path::{Path, PathBuf};
 
 pub struct ArchivableFilesFinder {
     pub(crate) finder: Finder,
-    inner_iter: Box<dyn Iterator<Item = SplFileInfo>>,
+    inner_iter: Box<dyn Iterator<Item = PathBuf>>,
 }
 
 impl std::fmt::Debug for ArchivableFilesFinder {
@@ -47,20 +47,18 @@ impl ArchivableFilesFinder {
         let mut finder = Finder::new();
 
         let sources_clone = sources.clone();
-        let filter = move |file: &SplFileInfo| -> bool {
-            let realpath = file.get_real_path();
-            if realpath.is_none() {
+        let filter = move |file: &Path| -> bool {
+            let Ok(realpath) = file.canonicalize() else {
                 return false;
-            }
-            let realpath = realpath.unwrap();
-            if file.is_link() && !realpath.starts_with(sources_clone.as_str()) {
+            };
+            if file.is_symlink() && !realpath.starts_with(&sources_clone) {
                 return false;
             }
 
             let relative_path = Preg::replace(
                 &format!("^{}", preg_quote(&sources_clone, Some('#'))),
                 "",
-                &fs.normalize_path(&realpath),
+                &fs.normalize_path(&realpath.to_string_lossy()),
             )
             .unwrap_or_default();
 
@@ -79,18 +77,21 @@ impl ArchivableFilesFinder {
             .ignore_dot_files(false)
             .sort_by_name();
 
-        let inner_iter: Box<dyn Iterator<Item = SplFileInfo>> = Box::new(finder.get_iterator());
+        let inner_iter: Box<dyn Iterator<Item = PathBuf>> = Box::new(
+            finder
+                .get_iterator()
+                .map(|f| PathBuf::from(f.get_pathname())),
+        );
 
         Ok(Self { finder, inner_iter })
     }
 
-    pub fn accept(&self, current: &SplFileInfo) -> bool {
+    pub fn accept(&self, current: &Path) -> bool {
         if !current.is_dir() {
             return true;
         }
 
-        let path = current.get_pathname();
-        match std::fs::read_dir(&path) {
+        match std::fs::read_dir(current) {
             Ok(mut iter) => iter.next().is_none(),
             Err(_) => false,
         }
@@ -114,7 +115,7 @@ impl ArchivableFilesFilter for ComposerExcludeFilter {
 }
 
 impl Iterator for ArchivableFilesFinder {
-    type Item = SplFileInfo;
+    type Item = PathBuf;
 
     fn next(&mut self) -> Option<Self::Item> {
         loop {
diff --git a/crates/shirabe/src/package/archiver/phar_archiver.rs b/crates/shirabe/src/package/archiver/phar_archiver.rs
index bf5332a..d2854eb 100644
--- a/crates/shirabe/src/package/archiver/phar_archiver.rs
+++ b/crates/shirabe/src/package/archiver/phar_archiver.rs
@@ -70,10 +70,7 @@ impl ArchiverInterface for PharArchiver {
                 *formats.get(format.as_str()).unwrap_or(&Phar::TAR),
             );
             let files = ArchivableFilesFinder::new(&sources, excludes, ignore_filters)?;
-            // TODO(phase-b): unify iterator types (ArchivableFilesFinder yields SplFileInfo,
-            // ArchivableFilesFilter expects PathBuf).
-            let mut files_only =
-                ArchivableFilesFilter::new(Box::new(files.map(|f| f.get_pathname().into())));
+            let mut files_only = ArchivableFilesFilter::new(Box::new(files));
             phar.build_from_iterator(&mut files_only, &sources);
             files_only.add_empty_dir(&phar, &sources);
 
diff --git a/crates/shirabe/src/package/archiver/zip_archiver.rs b/crates/shirabe/src/package/archiver/zip_archiver.rs
index 79d714b..7d9f126 100644
--- a/crates/shirabe/src/package/archiver/zip_archiver.rs
+++ b/crates/shirabe/src/package/archiver/zip_archiver.rs
@@ -8,6 +8,7 @@ use indexmap::IndexMap;
 use shirabe_php_shim::{
     PhpMixed, RuntimeException, ZipArchive, class_exists, fileperms, method_exists, pack, realpath,
 };
+use std::path::PathBuf;
 
 #[derive(Debug)]
 pub struct ZipArchiver;
@@ -50,24 +51,34 @@ impl ArchiverInterface for ZipArchiver {
         if zip.open(&target, ZipArchive::CREATE).is_ok() {
             let files = ArchivableFilesFinder::new(&sources, excludes, ignore_filters)?;
             for file in files {
-                let filepath = file.get_pathname();
-                let mut relative_path = file.get_relative_path_name();
+                let filepath = file;
+                let mut relative_path = filepath
+                    .strip_prefix(&sources)
+                    .unwrap_or(filepath.as_path())
+                    .to_path_buf();
 
                 if Platform::is_windows() {
-                    relative_path = shirabe_php_shim::strtr(&relative_path, "\\", "/");
+                    relative_path = PathBuf::from(shirabe_php_shim::strtr(
+                        &relative_path.to_string_lossy(),
+                        "\\",
+                        "/",
+                    ));
                 }
 
-                if file.is_dir() {
-                    zip.add_empty_dir(&relative_path);
+                if filepath.is_dir() {
+                    zip.add_empty_dir(&relative_path.to_string_lossy());
                 } else {
-                    zip.add_file(&filepath, &relative_path);
+                    zip.add_file(
+                        &filepath.to_string_lossy(),
+                        &relative_path.to_string_lossy(),
+                    );
                 }
 
                 // setExternalAttributesName() is only available with libzip 0.11.2 or above
                 if method_exists(&PhpMixed::Null, "setExternalAttributesName") {
-                    let perms = fileperms(&filepath);
+                    let perms = fileperms(&filepath.to_string_lossy());
                     zip.set_external_attributes_name(
-                        &relative_path,
+                        &relative_path.to_string_lossy(),
                         ZipArchive::OPSYS_UNIX,
                         perms << 16,
                     );