From 90764c477f24e4d67d3e0cae943c33fd2b8ae220 Mon Sep 17 00:00:00 2001 From: nsfisis Date: Thu, 6 Aug 2026 02:40:00 +0900 Subject: feat(plugin): widen the RPC surface to LibraryInstaller-based plugins An installer that extends LibraryInstaller reaches for the Composer object graph in ways the proxy did not answer: the download manager and the config, the writable repository methods, a React promise as its own return value, and `new Package(...)` from its supports() path. * `Composer::getConfig`/`getDownloadManager` are dispatched, and both classes become generated proxy stubs. Their reads and mutators answer from the Rust entity; the surfaces needing stubs of their own (ConfigSourceInterface, DownloaderInterface) stay explicit errors. * The download manager's futures are driven to completion and handed back as already-settled React promises, since PHP declares a non-nullable PromiseInterface there. A promise a plugin returns is drained the same way: settled yields its value, rejected re-raises, pending is an explicit error. * Proxy stubs now carry the real class's constructor and ask the Rust side to allocate the entity; reviving a stub for an existing entity binds the handle without running it. Classes Rust cannot build name themselves in the error. * The package proxy covers `Package`'s own setters, `CompletePackage`'s metadata, `RootPackage`'s root-only state, and `BasePackage::$id`. Link values and release dates still have no wire image, so the methods carrying them remain explicit errors. --- .../stubs/Composer/Downloader/DownloadManager.php | 128 +++++++++++++++++++++ 1 file changed, 128 insertions(+) create mode 100644 crates/shirabe-php-rpc/php/stubs/Composer/Downloader/DownloadManager.php (limited to 'crates/shirabe-php-rpc/php/stubs/Composer/Downloader') diff --git a/crates/shirabe-php-rpc/php/stubs/Composer/Downloader/DownloadManager.php b/crates/shirabe-php-rpc/php/stubs/Composer/Downloader/DownloadManager.php new file mode 100644 index 00000000..3828ac4a --- /dev/null +++ b/crates/shirabe-php-rpc/php/stubs/Composer/Downloader/DownloadManager.php @@ -0,0 +1,128 @@ +__rhandle = $rhandle; + $this->__epoch = $epoch; + } + + public function __destruct() + { + \ShirabeRustObjectRegistry::release($this->__rhandle); + } + + public function __shirabeRustHandleDescriptor(): array + { + return [ + '__rhandle' => $this->__rhandle, + '__class' => static::class, + '__epoch' => $this->__epoch, + ]; + } + + public function __clone() + { + // PHP has already shallow-copied this stub, so both copies would point at one + // entity and release it twice. The Rust side clones the entity instead, applying + // whatever __clone semantics the real class defines, and this copy rebinds to the + // fresh handle. Entities without clone semantics answer with an explicit error. + [$this->__rhandle, $this->__epoch] = \ShirabeRpcRuntime::callRust($this->__rhandle, '__shirabeClone', []); + \ShirabeRustObjectRegistry::adopt($this->__rhandle, $this); + } + + public function __construct(IOInterface $io, bool $preferSource = false, ?Filesystem $filesystem = null) + { + [$this->__rhandle, $this->__epoch] = \ShirabeRpcRuntime::callRust(0, '__shirabeConstruct', [static::class, [$io, $preferSource, $filesystem]]); + \ShirabeRustObjectRegistry::adopt($this->__rhandle, $this); + } + + public function setPreferSource(bool $preferSource): self + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'setPreferSource', [$preferSource]); + return $this; + } + + public function setPreferDist(bool $preferDist): self + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'setPreferDist', [$preferDist]); + return $this; + } + + public function setPreferences(array $preferences): self + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'setPreferences', [$preferences]); + return $this; + } + + public function setDownloader(string $type, DownloaderInterface $downloader): self + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'setDownloader', [$type, $downloader]); + return $this; + } + + public function getDownloader(string $type): DownloaderInterface + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getDownloader', [$type]); + } + + public function getDownloaderForPackage(PackageInterface $package): ?DownloaderInterface + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getDownloaderForPackage', [$package]); + } + + public function getDownloaderType(DownloaderInterface $downloader): string + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getDownloaderType', [$downloader]); + } + + public function download(PackageInterface $package, string $targetDir, ?PackageInterface $prevPackage = null): PromiseInterface + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'download', [$package, $targetDir, $prevPackage]); + } + + public function prepare(string $type, PackageInterface $package, string $targetDir, ?PackageInterface $prevPackage = null): PromiseInterface + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'prepare', [$type, $package, $targetDir, $prevPackage]); + } + + public function install(PackageInterface $package, string $targetDir): PromiseInterface + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'install', [$package, $targetDir]); + } + + public function update(PackageInterface $initial, PackageInterface $target, string $targetDir): PromiseInterface + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'update', [$initial, $target, $targetDir]); + } + + public function remove(PackageInterface $package, string $targetDir): PromiseInterface + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'remove', [$package, $targetDir]); + } + + public function cleanup(string $type, PackageInterface $package, string $targetDir, ?PackageInterface $prevPackage = null): PromiseInterface + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'cleanup', [$type, $package, $targetDir, $prevPackage]); + } +} -- cgit v1.3.1