1 files changed, 108 insertions, 3 deletions

diff --git a/crates/shirabe/src/downloader/rar_downloader.rs b/crates/shirabe/src/downloader/rar_downloader.rs
index 308b6fa..51feadb 100644
--- a/crates/shirabe/src/downloader/rar_downloader.rs
+++ b/crates/shirabe/src/downloader/rar_downloader.rs
@@ -1,25 +1,56 @@
 //! ref: composer/src/Composer/Downloader/RarDownloader.php
 
+use crate::cache::Cache;
+use crate::config::Config;
 use crate::downloader::archive_downloader::ArchiveDownloader;
 use crate::downloader::file_downloader::FileDownloader;
+use crate::event_dispatcher::event_dispatcher::EventDispatcher;
+use crate::io::io_interface::IOInterface;
 use crate::package::package_interface::PackageInterface;
+use crate::util::filesystem::Filesystem;
+use crate::util::http_downloader::HttpDownloader;
 use crate::util::ini_helper::IniHelper;
 use crate::util::platform::Platform;
+use crate::util::process_executor::ProcessExecutor;
 use anyhow::Result;
 use indexmap::IndexMap;
 use shirabe_external_packages::react::promise::promise_interface::PromiseInterface;
 use shirabe_php_shim::{
-    RarArchive, RuntimeException, UnexpectedValueException, class_exists, implode,
+    PhpMixed, RarArchive, RuntimeException, UnexpectedValueException, class_exists, implode,
 };
 
+#[derive(Debug)]
 pub struct RarDownloader {
     inner: FileDownloader,
     cleanup_executed: IndexMap<String, bool>,
 }
 
 impl RarDownloader {
+    pub fn new(
+        io: Box<dyn IOInterface>,
+        config: Config,
+        http_downloader: HttpDownloader,
+        event_dispatcher: Option<EventDispatcher>,
+        cache: Option<Cache>,
+        filesystem: Filesystem,
+        process: ProcessExecutor,
+    ) -> Self {
+        Self {
+            inner: FileDownloader::new(
+                io,
+                config,
+                http_downloader,
+                event_dispatcher,
+                cache,
+                Some(filesystem),
+                Some(process),
+            ),
+            cleanup_executed: IndexMap::new(),
+        }
+    }
+
     pub(crate) fn extract(
-        &self,
+        &mut self,
         _package: &dyn PackageInterface,
         file: &str,
         path: &str,
@@ -35,7 +66,18 @@ impl RarDownloader {
                 path.to_string(),
             ];
 
-            if self.inner.process.execute(&command, &mut String::new()) == 0 {
+            let mut process_output = PhpMixed::Null;
+            if self.inner.process.execute(
+                PhpMixed::List(
+                    command
+                        .iter()
+                        .map(|s| Box::new(PhpMixed::String(s.clone())))
+                        .collect(),
+                ),
+                Some(&mut process_output),
+                None,
+            )? == 0
+            {
                 return Ok(shirabe_external_packages::react::promise::resolve(None));
             }
 
@@ -101,3 +143,66 @@ impl RarDownloader {
         Ok(shirabe_external_packages::react::promise::resolve(None))
     }
 }
+
+impl crate::downloader::downloader_interface::DownloaderInterface for RarDownloader {
+    fn get_installation_source(&self) -> String {
+        self.inner.get_installation_source()
+    }
+
+    fn download(
+        &self,
+        package: &dyn PackageInterface,
+        path: &str,
+        prev_package: Option<&dyn PackageInterface>,
+        output: bool,
+    ) -> Result<Box<dyn PromiseInterface>> {
+        self.inner.download(package, path, prev_package, output)
+    }
+
+    fn prepare(
+        &self,
+        r#type: &str,
+        package: &dyn PackageInterface,
+        path: &str,
+        prev_package: Option<&dyn PackageInterface>,
+    ) -> Result<Box<dyn PromiseInterface>> {
+        self.inner.prepare(r#type, package, path, prev_package)
+    }
+
+    fn install(
+        &self,
+        package: &dyn PackageInterface,
+        path: &str,
+        output: bool,
+    ) -> Result<Box<dyn PromiseInterface>> {
+        self.inner.install(package, path, output)
+    }
+
+    fn update(
+        &self,
+        initial: &dyn PackageInterface,
+        target: &dyn PackageInterface,
+        path: &str,
+    ) -> Result<Box<dyn PromiseInterface>> {
+        self.inner.update(initial, target, path)
+    }
+
+    fn remove(
+        &self,
+        package: &dyn PackageInterface,
+        path: &str,
+        output: bool,
+    ) -> Result<Box<dyn PromiseInterface>> {
+        self.inner.remove(package, path, output)
+    }
+
+    fn cleanup(
+        &self,
+        r#type: &str,
+        package: &dyn PackageInterface,
+        path: &str,
+        prev_package: Option<&dyn PackageInterface>,
+    ) -> Result<Box<dyn PromiseInterface>> {
+        self.inner.cleanup(r#type, package, path, prev_package)
+    }
+}