feat(repository): resolve repository phase-b TODOs

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

1 files changed, 105 insertions, 6 deletions

diff --git a/crates/shirabe/src/repository/writable_array_repository.rs b/crates/shirabe/src/repository/writable_array_repository.rs
index 0615ef6..c4b31aa 100644
--- a/crates/shirabe/src/repository/writable_array_repository.rs
+++ b/crates/shirabe/src/repository/writable_array_repository.rs
@@ -1,10 +1,15 @@
 //! ref: composer/src/Composer/Repository/WritableArrayRepository.php
 
 use crate::installer::InstallationManager;
+use crate::package::BasePackageHandle;
+use crate::package::PackageInterfaceHandle;
 use crate::repository::ArrayRepository;
 use crate::repository::RepositoryInterface;
 use crate::repository::RepositoryInterfaceWeakHandle;
+use crate::repository::{FindPackageConstraint, LoadPackagesResult, ProviderInfo, SearchResult};
 use anyhow::Result;
+use indexmap::IndexMap;
+use shirabe_semver::constraint::AnyConstraint;
 
 #[derive(Debug)]
 pub struct WritableArrayRepository {
@@ -52,6 +57,10 @@ impl WritableArrayRepository {
         self.inner.reset_packages();
     }
 
+    pub(crate) fn is_initialized(&self) -> bool {
+        self.inner.is_initialized()
+    }
+
     pub fn add_package(&mut self, package: crate::package::PackageInterfaceHandle) -> Result<()> {
         self.inner.add_package(package)
     }
@@ -64,19 +73,43 @@ impl WritableArrayRepository {
         &mut self,
         package: crate::package::PackageInterfaceHandle,
     ) -> Result<()> {
-        let _ = package;
-        // TODO(phase-b): delegate to ArrayRepository once it implements remove_package
+        self.inner.remove_package(package);
         Ok(())
     }
 
     pub fn initialize(&mut self) -> Result<()> {
-        // TODO(phase-b): inner ArrayRepository::initialize signature
+        self.inner.initialize();
         Ok(())
     }
 
+    /// Get unique packages (at most one package of each name), with aliases resolved and removed.
     pub fn get_canonical_packages(&self) -> Vec<crate::package::PackageInterfaceHandle> {
-        // TODO(phase-b): delegate to inner once it exposes get_canonical_packages
-        Vec::new()
+        let packages = self.inner.get_packages_internal();
+
+        // get at most one package of each name, preferring non-aliased ones
+        let mut packages_by_name: IndexMap<String, crate::package::PackageInterfaceHandle> =
+            IndexMap::new();
+        for package in packages {
+            let name = package.get_name();
+            let prefer_replace = packages_by_name
+                .get(&name)
+                .map(|existing| existing.as_alias().is_some())
+                .unwrap_or(true);
+            if prefer_replace {
+                packages_by_name.insert(name, package);
+            }
+        }
+
+        // unfold aliased packages
+        let mut canonical_packages = Vec::new();
+        for mut package in packages_by_name.into_values() {
+            while let Some(alias) = package.as_alias() {
+                package = alias.get_alias_of().into();
+            }
+            canonical_packages.push(package);
+        }
+
+        canonical_packages
     }
 
     pub fn get_packages(&mut self) -> anyhow::Result<Vec<crate::package::BasePackageHandle>> {
@@ -86,8 +119,74 @@ impl WritableArrayRepository {
     pub fn get_repo_name(&self) -> String {
         self.inner.get_repo_name()
     }
+}
 
-    pub fn count(&self) -> anyhow::Result<usize> {
+impl RepositoryInterface for WritableArrayRepository {
+    fn count(&self) -> anyhow::Result<usize> {
         self.inner.count()
     }
+
+    fn has_package(&self, package: PackageInterfaceHandle) -> bool {
+        self.inner.has_package(package)
+    }
+
+    fn find_package(
+        &mut self,
+        name: &str,
+        constraint: FindPackageConstraint,
+    ) -> Result<Option<BasePackageHandle>> {
+        self.inner.find_package(name, constraint)
+    }
+
+    fn find_packages(
+        &mut self,
+        name: &str,
+        constraint: Option<FindPackageConstraint>,
+    ) -> Result<Vec<BasePackageHandle>> {
+        self.inner.find_packages(name, constraint)
+    }
+
+    fn get_packages(&mut self) -> Result<Vec<BasePackageHandle>> {
+        self.inner.get_packages()
+    }
+
+    fn load_packages(
+        &mut self,
+        package_name_map: IndexMap<String, Option<AnyConstraint>>,
+        acceptable_stabilities: IndexMap<String, i64>,
+        stability_flags: IndexMap<String, i64>,
+        already_loaded: IndexMap<String, IndexMap<String, PackageInterfaceHandle>>,
+    ) -> Result<LoadPackagesResult> {
+        self.inner.load_packages(
+            package_name_map,
+            acceptable_stabilities,
+            stability_flags,
+            already_loaded,
+        )
+    }
+
+    fn search(
+        &mut self,
+        query: String,
+        mode: i64,
+        r#type: Option<String>,
+    ) -> Result<Vec<SearchResult>> {
+        self.inner.search(query, mode, r#type)
+    }
+
+    fn get_providers(&mut self, package_name: String) -> Result<IndexMap<String, ProviderInfo>> {
+        self.inner.get_providers(package_name)
+    }
+
+    fn get_repo_name(&self) -> String {
+        self.inner.get_repo_name()
+    }
+
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
+    fn set_self_handle(&self, weak: RepositoryInterfaceWeakHandle) {
+        self.inner.set_self_handle(weak);
+    }
 }