diff options
Diffstat (limited to 'crates/shirabe-php-rpc/php/guards/Composer/Util')
17 files changed, 1306 insertions, 0 deletions
diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/AuthHelper.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/AuthHelper.php new file mode 100644 index 00000000..a17ce769 --- /dev/null +++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/AuthHelper.php @@ -0,0 +1,45 @@ +<?php + +// Generated by scripts/plugin-stub-generator; do not edit by hand. +// Guard for Composer\Util\AuthHelper. +// The Rust side owns this class and the worker has no proxy for it, so this +// declaration shadows the real one: the constants and the hierarchy stay, while +// constructing it or calling anything on it raises an explicit error. + +namespace Composer\Util; + +use Composer\Config; +use Composer\IO\IOInterface; + +class AuthHelper +{ + public function __construct(IOInterface $io, Config $config) + { + \ShirabeUnsupportedClass::fail(self::class, '__construct'); + } + + public function storeAuth(string $origin, $storeAuth): void + { + \ShirabeUnsupportedClass::fail(self::class, 'storeAuth'); + } + + public function promptAuthIfNeeded(string $url, string $origin, int $statusCode, ?string $reason = null, array $headers = [], int $retryCount = 0, ?string $responseBody = null): array + { + \ShirabeUnsupportedClass::fail(self::class, 'promptAuthIfNeeded'); + } + + public function addAuthenticationHeader(array $headers, string $origin, string $url): array + { + \ShirabeUnsupportedClass::fail(self::class, 'addAuthenticationHeader'); + } + + public function addAuthenticationOptions(array $options, string $origin, string $url): array + { + \ShirabeUnsupportedClass::fail(self::class, 'addAuthenticationOptions'); + } + + public function isPublicBitBucketDownload(string $urlToBitBucketFile): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'isPublicBitBucketDownload'); + } +} diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/Bitbucket.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/Bitbucket.php new file mode 100644 index 00000000..b85c4b45 --- /dev/null +++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/Bitbucket.php @@ -0,0 +1,42 @@ +<?php + +// Generated by scripts/plugin-stub-generator; do not edit by hand. +// Guard for Composer\Util\Bitbucket. +// The Rust side owns this class and the worker has no proxy for it, so this +// declaration shadows the real one: the constants and the hierarchy stay, while +// constructing it or calling anything on it raises an explicit error. + +namespace Composer\Util; + +use Composer\IO\IOInterface; +use Composer\Config; + +class Bitbucket +{ + public const OAUTH2_ACCESS_TOKEN_URL = 'https://bitbucket.org/site/oauth2/access_token'; + + public function __construct(IOInterface $io, Config $config, ?ProcessExecutor $process = null, ?HttpDownloader $httpDownloader = null, ?int $time = null) + { + \ShirabeUnsupportedClass::fail(self::class, '__construct'); + } + + public function getToken(): string + { + \ShirabeUnsupportedClass::fail(self::class, 'getToken'); + } + + public function authorizeOAuth(string $originUrl): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'authorizeOAuth'); + } + + public function authorizeOAuthInteractively(string $originUrl, ?string $message = null): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'authorizeOAuthInteractively'); + } + + public function requestToken(string $originUrl, string $consumerKey, string $consumerSecret): string + { + \ShirabeUnsupportedClass::fail(self::class, 'requestToken'); + } +} diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/ConfigValidator.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/ConfigValidator.php new file mode 100644 index 00000000..0e35d197 --- /dev/null +++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/ConfigValidator.php @@ -0,0 +1,27 @@ +<?php + +// Generated by scripts/plugin-stub-generator; do not edit by hand. +// Guard for Composer\Util\ConfigValidator. +// The Rust side owns this class and the worker has no proxy for it, so this +// declaration shadows the real one: the constants and the hierarchy stay, while +// constructing it or calling anything on it raises an explicit error. + +namespace Composer\Util; + +use Composer\Package\Loader\ValidatingArrayLoader; +use Composer\IO\IOInterface; + +class ConfigValidator +{ + public const CHECK_VERSION = 1; + + public function __construct(IOInterface $io) + { + \ShirabeUnsupportedClass::fail(self::class, '__construct'); + } + + public function validate(string $file, int $arrayLoaderValidationFlags = ValidatingArrayLoader::CHECK_ALL, int $flags = self::CHECK_VERSION): array + { + \ShirabeUnsupportedClass::fail(self::class, 'validate'); + } +} diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/Filesystem.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/Filesystem.php new file mode 100644 index 00000000..6d8dbb24 --- /dev/null +++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/Filesystem.php @@ -0,0 +1,167 @@ +<?php + +// Generated by scripts/plugin-stub-generator; do not edit by hand. +// Guard for Composer\Util\Filesystem. +// The Rust side owns this class and the worker has no proxy for it, so this +// declaration shadows the real one: the constants and the hierarchy stay, while +// constructing it or calling anything on it raises an explicit error. + +namespace Composer\Util; + +class Filesystem +{ + public function __construct(?ProcessExecutor $executor = null) + { + \ShirabeUnsupportedClass::fail(self::class, '__construct'); + } + + public function remove(string $file) + { + \ShirabeUnsupportedClass::fail(self::class, 'remove'); + } + + public function isDirEmpty(string $dir) + { + \ShirabeUnsupportedClass::fail(self::class, 'isDirEmpty'); + } + + public function emptyDirectory(string $dir, bool $ensureDirectoryExists = true) + { + \ShirabeUnsupportedClass::fail(self::class, 'emptyDirectory'); + } + + public function removeDirectory(string $directory) + { + \ShirabeUnsupportedClass::fail(self::class, 'removeDirectory'); + } + + public function removeDirectoryAsync(string $directory) + { + \ShirabeUnsupportedClass::fail(self::class, 'removeDirectoryAsync'); + } + + public function removeDirectoryPhp(string $directory) + { + \ShirabeUnsupportedClass::fail(self::class, 'removeDirectoryPhp'); + } + + public function ensureDirectoryExists(string $directory) + { + \ShirabeUnsupportedClass::fail(self::class, 'ensureDirectoryExists'); + } + + public function unlink(string $path) + { + \ShirabeUnsupportedClass::fail(self::class, 'unlink'); + } + + public function rmdir(string $path) + { + \ShirabeUnsupportedClass::fail(self::class, 'rmdir'); + } + + public function copyThenRemove(string $source, string $target) + { + \ShirabeUnsupportedClass::fail(self::class, 'copyThenRemove'); + } + + public function copy(string $source, string $target) + { + \ShirabeUnsupportedClass::fail(self::class, 'copy'); + } + + public function rename(string $source, string $target) + { + \ShirabeUnsupportedClass::fail(self::class, 'rename'); + } + + public function findShortestPath(string $from, string $to, bool $directories = false, bool $preferRelative = false) + { + \ShirabeUnsupportedClass::fail(self::class, 'findShortestPath'); + } + + public function findShortestPathCode(string $from, string $to, bool $directories = false, bool $staticCode = false, bool $preferRelative = false) + { + \ShirabeUnsupportedClass::fail(self::class, 'findShortestPathCode'); + } + + public function isAbsolutePath(string $path) + { + \ShirabeUnsupportedClass::fail(self::class, 'isAbsolutePath'); + } + + public function size(string $path) + { + \ShirabeUnsupportedClass::fail(self::class, 'size'); + } + + public function normalizePath(string $path) + { + \ShirabeUnsupportedClass::fail(self::class, 'normalizePath'); + } + + public static function trimTrailingSlash(string $path) + { + \ShirabeUnsupportedClass::fail(self::class, 'trimTrailingSlash'); + } + + public static function isLocalPath(string $path) + { + \ShirabeUnsupportedClass::fail(self::class, 'isLocalPath'); + } + + public static function getPlatformPath(string $path) + { + \ShirabeUnsupportedClass::fail(self::class, 'getPlatformPath'); + } + + public static function isReadable(string $path) + { + \ShirabeUnsupportedClass::fail(self::class, 'isReadable'); + } + + protected function directorySize(string $directory) + { + \ShirabeUnsupportedClass::fail(self::class, 'directorySize'); + } + + protected function getProcess() + { + \ShirabeUnsupportedClass::fail(self::class, 'getProcess'); + } + + public function relativeSymlink(string $target, string $link) + { + \ShirabeUnsupportedClass::fail(self::class, 'relativeSymlink'); + } + + public function isSymlinkedDirectory(string $directory) + { + \ShirabeUnsupportedClass::fail(self::class, 'isSymlinkedDirectory'); + } + + public function junction(string $target, string $junction) + { + \ShirabeUnsupportedClass::fail(self::class, 'junction'); + } + + public function isJunction(string $junction) + { + \ShirabeUnsupportedClass::fail(self::class, 'isJunction'); + } + + public function removeJunction(string $junction) + { + \ShirabeUnsupportedClass::fail(self::class, 'removeJunction'); + } + + public function filePutContentsIfModified(string $path, string $content) + { + \ShirabeUnsupportedClass::fail(self::class, 'filePutContentsIfModified'); + } + + public function safeCopy(string $source, string $target): void + { + \ShirabeUnsupportedClass::fail(self::class, 'safeCopy'); + } +} diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/Git.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/Git.php new file mode 100644 index 00000000..df78b1f1 --- /dev/null +++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/Git.php @@ -0,0 +1,100 @@ +<?php + +// Generated by scripts/plugin-stub-generator; do not edit by hand. +// Guard for Composer\Util\Git. +// The Rust side owns this class and the worker has no proxy for it, so this +// declaration shadows the real one: the constants and the hierarchy stay, while +// constructing it or calling anything on it raises an explicit error. + +namespace Composer\Util; + +use Composer\Config; +use Composer\IO\IOInterface; + +class Git +{ + public function __construct(IOInterface $io, Config $config, ProcessExecutor $process, Filesystem $fs) + { + \ShirabeUnsupportedClass::fail(self::class, '__construct'); + } + + public static function checkForRepoOwnershipError(string $output, string $path, ?IOInterface $io = null): void + { + \ShirabeUnsupportedClass::fail(self::class, 'checkForRepoOwnershipError'); + } + + public function setHttpDownloader(HttpDownloader $httpDownloader): void + { + \ShirabeUnsupportedClass::fail(self::class, 'setHttpDownloader'); + } + + public function runCommands(array $commands, string $url, ?string $cwd, bool $initialClone = false, &$commandOutput = null): void + { + \ShirabeUnsupportedClass::fail(self::class, 'runCommands'); + } + + public function runCommand($commandCallable, string $url, ?string $cwd, bool $initialClone = false, &$commandOutput = null): void + { + \ShirabeUnsupportedClass::fail(self::class, 'runCommand'); + } + + public function syncMirror(string $url, string $dir): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'syncMirror'); + } + + public function fetchRefOrSyncMirror(string $url, string $dir, string $ref, ?string $prettyVersion = null): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'fetchRefOrSyncMirror'); + } + + public static function getNoShowSignatureFlag(ProcessExecutor $process): string + { + \ShirabeUnsupportedClass::fail(self::class, 'getNoShowSignatureFlag'); + } + + public static function getNoShowSignatureFlags(ProcessExecutor $process): array + { + \ShirabeUnsupportedClass::fail(self::class, 'getNoShowSignatureFlags'); + } + + public static function supportsNoCommitHeaderFlag(ProcessExecutor $process): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'supportsNoCommitHeaderFlag'); + } + + public static function buildRevListCommand(ProcessExecutor $process, array $arguments): array + { + \ShirabeUnsupportedClass::fail(self::class, 'buildRevListCommand'); + } + + public static function parseRevListOutput(string $output, ProcessExecutor $process): string + { + \ShirabeUnsupportedClass::fail(self::class, 'parseRevListOutput'); + } + + public function getMirrorDefaultBranch(string $url, string $dir, bool $isLocalPathRepository): ?string + { + \ShirabeUnsupportedClass::fail(self::class, 'getMirrorDefaultBranch'); + } + + public static function cleanEnv(?ProcessExecutor $process = null): void + { + \ShirabeUnsupportedClass::fail(self::class, 'cleanEnv'); + } + + public static function getGitHubDomainsRegex(Config $config): string + { + \ShirabeUnsupportedClass::fail(self::class, 'getGitHubDomainsRegex'); + } + + public static function getGitLabDomainsRegex(Config $config): string + { + \ShirabeUnsupportedClass::fail(self::class, 'getGitLabDomainsRegex'); + } + + public static function getVersion(ProcessExecutor $process): ?string + { + \ShirabeUnsupportedClass::fail(self::class, 'getVersion'); + } +} diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/GitHub.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/GitHub.php new file mode 100644 index 00000000..e6dadefb --- /dev/null +++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/GitHub.php @@ -0,0 +1,52 @@ +<?php + +// Generated by scripts/plugin-stub-generator; do not edit by hand. +// Guard for Composer\Util\GitHub. +// The Rust side owns this class and the worker has no proxy for it, so this +// declaration shadows the real one: the constants and the hierarchy stay, while +// constructing it or calling anything on it raises an explicit error. + +namespace Composer\Util; + +use Composer\IO\IOInterface; +use Composer\Config; + +class GitHub +{ + public const GITHUB_TOKEN_REGEX = '{^([a-f0-9]{12,}|gh[a-z]_[a-zA-Z0-9_]+|github_pat_[a-zA-Z0-9_]+)$}'; + + public function __construct(IOInterface $io, Config $config, ?ProcessExecutor $process = null, ?HttpDownloader $httpDownloader = null) + { + \ShirabeUnsupportedClass::fail(self::class, '__construct'); + } + + public function authorizeOAuth(string $originUrl): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'authorizeOAuth'); + } + + public function authorizeOAuthInteractively(string $originUrl, ?string $message = null): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'authorizeOAuthInteractively'); + } + + public function getRateLimit(array $headers): array + { + \ShirabeUnsupportedClass::fail(self::class, 'getRateLimit'); + } + + public function getSsoUrl(array $headers): ?string + { + \ShirabeUnsupportedClass::fail(self::class, 'getSsoUrl'); + } + + public function isRateLimited(array $headers): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'isRateLimited'); + } + + public function requiresSso(array $headers): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'requiresSso'); + } +} diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/GitLab.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/GitLab.php new file mode 100644 index 00000000..4c131f61 --- /dev/null +++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/GitLab.php @@ -0,0 +1,40 @@ +<?php + +// Generated by scripts/plugin-stub-generator; do not edit by hand. +// Guard for Composer\Util\GitLab. +// The Rust side owns this class and the worker has no proxy for it, so this +// declaration shadows the real one: the constants and the hierarchy stay, while +// constructing it or calling anything on it raises an explicit error. + +namespace Composer\Util; + +use Composer\IO\IOInterface; +use Composer\Config; + +class GitLab +{ + public function __construct(IOInterface $io, Config $config, ?ProcessExecutor $process = null, ?HttpDownloader $httpDownloader = null) + { + \ShirabeUnsupportedClass::fail(self::class, '__construct'); + } + + public function authorizeOAuth(string $originUrl): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'authorizeOAuth'); + } + + public function authorizeOAuthInteractively(string $scheme, string $originUrl, ?string $message = null): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'authorizeOAuthInteractively'); + } + + public function authorizeOAuthRefresh(string $scheme, string $originUrl): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'authorizeOAuthRefresh'); + } + + public function isOAuthExpired(string $originUrl): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'isOAuthExpired'); + } +} diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/Http/CurlDownloader.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/Http/CurlDownloader.php new file mode 100644 index 00000000..5e362356 --- /dev/null +++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/Http/CurlDownloader.php @@ -0,0 +1,37 @@ +<?php + +// Generated by scripts/plugin-stub-generator; do not edit by hand. +// Guard for Composer\Util\Http\CurlDownloader. +// The Rust side owns this class and the worker has no proxy for it, so this +// declaration shadows the real one: the constants and the hierarchy stay, while +// constructing it or calling anything on it raises an explicit error. + +namespace Composer\Util\Http; + +use Composer\Config; +use Composer\IO\IOInterface; + +class CurlDownloader +{ + private const BAD_MULTIPLEXING_CURL_VERSIONS = ['7.87.0', '7.88.0', '7.88.1']; + + public function __construct(IOInterface $io, Config $config, array $options = [], bool $disableTls = false) + { + \ShirabeUnsupportedClass::fail(self::class, '__construct'); + } + + public function download(callable $resolve, callable $reject, string $origin, string $url, array $options, ?string $copyTo = null): int + { + \ShirabeUnsupportedClass::fail(self::class, 'download'); + } + + public function abortRequest(int $id): void + { + \ShirabeUnsupportedClass::fail(self::class, 'abortRequest'); + } + + public function tick(): void + { + \ShirabeUnsupportedClass::fail(self::class, 'tick'); + } +} diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/Http/CurlResponse.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/Http/CurlResponse.php new file mode 100644 index 00000000..ae229589 --- /dev/null +++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/Http/CurlResponse.php @@ -0,0 +1,22 @@ +<?php + +// Generated by scripts/plugin-stub-generator; do not edit by hand. +// Guard for Composer\Util\Http\CurlResponse. +// The Rust side owns this class and the worker has no proxy for it, so this +// declaration shadows the real one: the constants and the hierarchy stay, while +// constructing it or calling anything on it raises an explicit error. + +namespace Composer\Util\Http; + +class CurlResponse extends Response +{ + public function __construct(array $request, ?int $code, array $headers, ?string $body, array $curlInfo) + { + \ShirabeUnsupportedClass::fail(self::class, '__construct'); + } + + public function getCurlInfo(): array + { + \ShirabeUnsupportedClass::fail(self::class, 'getCurlInfo'); + } +} diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/Http/Response.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/Http/Response.php new file mode 100644 index 00000000..61eebb7f --- /dev/null +++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/Http/Response.php @@ -0,0 +1,57 @@ +<?php + +// Generated by scripts/plugin-stub-generator; do not edit by hand. +// Guard for Composer\Util\Http\Response. +// The Rust side owns this class and the worker has no proxy for it, so this +// declaration shadows the real one: the constants and the hierarchy stay, while +// constructing it or calling anything on it raises an explicit error. + +namespace Composer\Util\Http; + +class Response +{ + public function __construct(array $request, ?int $code, array $headers, ?string $body) + { + \ShirabeUnsupportedClass::fail(self::class, '__construct'); + } + + public function getStatusCode(): int + { + \ShirabeUnsupportedClass::fail(self::class, 'getStatusCode'); + } + + public function getStatusMessage(): ?string + { + \ShirabeUnsupportedClass::fail(self::class, 'getStatusMessage'); + } + + public function getHeaders(): array + { + \ShirabeUnsupportedClass::fail(self::class, 'getHeaders'); + } + + public function getHeader(string $name): ?string + { + \ShirabeUnsupportedClass::fail(self::class, 'getHeader'); + } + + public function getBody(): ?string + { + \ShirabeUnsupportedClass::fail(self::class, 'getBody'); + } + + public function decodeJson() + { + \ShirabeUnsupportedClass::fail(self::class, 'decodeJson'); + } + + public function collect(): void + { + \ShirabeUnsupportedClass::fail(self::class, 'collect'); + } + + public static function findHeaderValue(array $headers, string $name): ?string + { + \ShirabeUnsupportedClass::fail(self::class, 'findHeaderValue'); + } +} diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/HttpDownloader.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/HttpDownloader.php new file mode 100644 index 00000000..a2fad123 --- /dev/null +++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/HttpDownloader.php @@ -0,0 +1,86 @@ +<?php + +// Generated by scripts/plugin-stub-generator; do not edit by hand. +// Guard for Composer\Util\HttpDownloader. +// The Rust side owns this class and the worker has no proxy for it, so this +// declaration shadows the real one: the constants and the hierarchy stay, while +// constructing it or calling anything on it raises an explicit error. + +namespace Composer\Util; + +use Composer\Config; +use Composer\IO\IOInterface; + +class HttpDownloader +{ + private const STATUS_QUEUED = 1; + private const STATUS_STARTED = 2; + private const STATUS_COMPLETED = 3; + private const STATUS_FAILED = 4; + private const STATUS_ABORTED = 5; + + public function __construct(IOInterface $io, Config $config, array $options = [], bool $disableTls = false) + { + \ShirabeUnsupportedClass::fail(self::class, '__construct'); + } + + public function get(string $url, array $options = []) + { + \ShirabeUnsupportedClass::fail(self::class, 'get'); + } + + public function add(string $url, array $options = []) + { + \ShirabeUnsupportedClass::fail(self::class, 'add'); + } + + public function copy(string $url, string $to, array $options = []) + { + \ShirabeUnsupportedClass::fail(self::class, 'copy'); + } + + public function addCopy(string $url, string $to, array $options = []) + { + \ShirabeUnsupportedClass::fail(self::class, 'addCopy'); + } + + public function getOptions() + { + \ShirabeUnsupportedClass::fail(self::class, 'getOptions'); + } + + public function setOptions(array $options) + { + \ShirabeUnsupportedClass::fail(self::class, 'setOptions'); + } + + public function wait(?int $index = null) + { + \ShirabeUnsupportedClass::fail(self::class, 'wait'); + } + + public function enableAsync(): void + { + \ShirabeUnsupportedClass::fail(self::class, 'enableAsync'); + } + + public function countActiveJobs(?int $index = null): int + { + \ShirabeUnsupportedClass::fail(self::class, 'countActiveJobs'); + } + + public static function outputWarnings(IOInterface $io, string $url, $data): void + { + \ShirabeUnsupportedClass::fail(self::class, 'outputWarnings'); + } + + public static function getExceptionHints(\Throwable $e): ?array + { + \ShirabeUnsupportedClass::fail(self::class, 'getExceptionHints'); + } + + public static function isCurlEnabled(): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'isCurlEnabled'); + } +} diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/Loop.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/Loop.php new file mode 100644 index 00000000..32648ece --- /dev/null +++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/Loop.php @@ -0,0 +1,39 @@ +<?php + +// Generated by scripts/plugin-stub-generator; do not edit by hand. +// Guard for Composer\Util\Loop. +// The Rust side owns this class and the worker has no proxy for it, so this +// declaration shadows the real one: the constants and the hierarchy stay, while +// constructing it or calling anything on it raises an explicit error. + +namespace Composer\Util; + +use Symfony\Component\Console\Helper\ProgressBar; + +class Loop +{ + public function __construct(HttpDownloader $httpDownloader, ?ProcessExecutor $processExecutor = null) + { + \ShirabeUnsupportedClass::fail(self::class, '__construct'); + } + + public function getHttpDownloader(): HttpDownloader + { + \ShirabeUnsupportedClass::fail(self::class, 'getHttpDownloader'); + } + + public function getProcessExecutor(): ?ProcessExecutor + { + \ShirabeUnsupportedClass::fail(self::class, 'getProcessExecutor'); + } + + public function wait(array $promises, ?ProgressBar $progress = null): void + { + \ShirabeUnsupportedClass::fail(self::class, 'wait'); + } + + public function abortJobs(): void + { + \ShirabeUnsupportedClass::fail(self::class, 'abortJobs'); + } +} diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/Perforce.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/Perforce.php new file mode 100644 index 00000000..892317b9 --- /dev/null +++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/Perforce.php @@ -0,0 +1,219 @@ +<?php + +// Generated by scripts/plugin-stub-generator; do not edit by hand. +// Guard for Composer\Util\Perforce. +// The Rust side owns this class and the worker has no proxy for it, so this +// declaration shadows the real one: the constants and the hierarchy stay, while +// constructing it or calling anything on it raises an explicit error. + +namespace Composer\Util; + +use Composer\IO\IOInterface; + +class Perforce +{ + public function __construct($repoConfig, string $port, string $path, ProcessExecutor $process, bool $isWindows, IOInterface $io) + { + \ShirabeUnsupportedClass::fail(self::class, '__construct'); + } + + public static function create($repoConfig, string $port, string $path, ProcessExecutor $process, IOInterface $io): self + { + \ShirabeUnsupportedClass::fail(self::class, 'create'); + } + + public static function checkServerExists(string $url, ProcessExecutor $processExecutor): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'checkServerExists'); + } + + public function initialize($repoConfig): void + { + \ShirabeUnsupportedClass::fail(self::class, 'initialize'); + } + + public function initializeDepotAndBranch(?string $depot, ?string $branch): void + { + \ShirabeUnsupportedClass::fail(self::class, 'initializeDepotAndBranch'); + } + + public function generateUniquePerforceClientName(): string + { + \ShirabeUnsupportedClass::fail(self::class, 'generateUniquePerforceClientName'); + } + + public function cleanupClientSpec(): void + { + \ShirabeUnsupportedClass::fail(self::class, 'cleanupClientSpec'); + } + + protected function executeCommand($command): int + { + \ShirabeUnsupportedClass::fail(self::class, 'executeCommand'); + } + + public function getClient(): string + { + \ShirabeUnsupportedClass::fail(self::class, 'getClient'); + } + + protected function getPath(): string + { + \ShirabeUnsupportedClass::fail(self::class, 'getPath'); + } + + public function initializePath(string $path): void + { + \ShirabeUnsupportedClass::fail(self::class, 'initializePath'); + } + + protected function getPort(): string + { + \ShirabeUnsupportedClass::fail(self::class, 'getPort'); + } + + public function setStream(string $stream): void + { + \ShirabeUnsupportedClass::fail(self::class, 'setStream'); + } + + public function isStream(): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'isStream'); + } + + public function getStream(): string + { + \ShirabeUnsupportedClass::fail(self::class, 'getStream'); + } + + public function getStreamWithoutLabel(string $stream): string + { + \ShirabeUnsupportedClass::fail(self::class, 'getStreamWithoutLabel'); + } + + public function getP4ClientSpec(): string + { + \ShirabeUnsupportedClass::fail(self::class, 'getP4ClientSpec'); + } + + public function getUser(): ?string + { + \ShirabeUnsupportedClass::fail(self::class, 'getUser'); + } + + public function setUser(?string $user): void + { + \ShirabeUnsupportedClass::fail(self::class, 'setUser'); + } + + public function queryP4User(): void + { + \ShirabeUnsupportedClass::fail(self::class, 'queryP4User'); + } + + protected function getP4variable(string $name): ?string + { + \ShirabeUnsupportedClass::fail(self::class, 'getP4variable'); + } + + public function queryP4Password(): ?string + { + \ShirabeUnsupportedClass::fail(self::class, 'queryP4Password'); + } + + public function generateP4Command(array $arguments, bool $useClient = true): array + { + \ShirabeUnsupportedClass::fail(self::class, 'generateP4Command'); + } + + public function isLoggedIn(): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'isLoggedIn'); + } + + public function connectClient(): void + { + \ShirabeUnsupportedClass::fail(self::class, 'connectClient'); + } + + public function syncCodeBase(?string $sourceReference): void + { + \ShirabeUnsupportedClass::fail(self::class, 'syncCodeBase'); + } + + public function writeClientSpecToFile($spec): void + { + \ShirabeUnsupportedClass::fail(self::class, 'writeClientSpecToFile'); + } + + public function writeP4ClientSpec(): void + { + \ShirabeUnsupportedClass::fail(self::class, 'writeP4ClientSpec'); + } + + protected function read($pipe, $name): void + { + \ShirabeUnsupportedClass::fail(self::class, 'read'); + } + + public function windowsLogin(?string $password): int + { + \ShirabeUnsupportedClass::fail(self::class, 'windowsLogin'); + } + + public function p4Login(): void + { + \ShirabeUnsupportedClass::fail(self::class, 'p4Login'); + } + + public function getComposerInformation(string $identifier): ?array + { + \ShirabeUnsupportedClass::fail(self::class, 'getComposerInformation'); + } + + public function getFileContent(string $file, string $identifier): ?string + { + \ShirabeUnsupportedClass::fail(self::class, 'getFileContent'); + } + + public function getFilePath(string $file, string $identifier): ?string + { + \ShirabeUnsupportedClass::fail(self::class, 'getFilePath'); + } + + public function getBranches(): array + { + \ShirabeUnsupportedClass::fail(self::class, 'getBranches'); + } + + public function getTags(): array + { + \ShirabeUnsupportedClass::fail(self::class, 'getTags'); + } + + public function checkStream(): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'checkStream'); + } + + protected function getChangeList(string $reference): mixed + { + \ShirabeUnsupportedClass::fail(self::class, 'getChangeList'); + } + + public function getCommitLogs(string $fromReference, string $toReference): mixed + { + \ShirabeUnsupportedClass::fail(self::class, 'getCommitLogs'); + } + + public function getFilesystem(): Filesystem + { + \ShirabeUnsupportedClass::fail(self::class, 'getFilesystem'); + } + + public function setFilesystem(Filesystem $fs): void + { + \ShirabeUnsupportedClass::fail(self::class, 'setFilesystem'); + } +} diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/Platform.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/Platform.php new file mode 100644 index 00000000..2384723d --- /dev/null +++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/Platform.php @@ -0,0 +1,92 @@ +<?php + +// Generated by scripts/plugin-stub-generator; do not edit by hand. +// Guard for Composer\Util\Platform. +// The Rust side owns this class and the worker has no proxy for it, so this +// declaration shadows the real one: the constants and the hierarchy stay, while +// constructing it or calling anything on it raises an explicit error. + +namespace Composer\Util; + +class Platform +{ + public function __construct() + { + \ShirabeUnsupportedClass::fail(self::class, '__construct'); + } + + public static function getCwd(bool $allowEmpty = false): string + { + \ShirabeUnsupportedClass::fail(self::class, 'getCwd'); + } + + public static function realpath(string $path): string + { + \ShirabeUnsupportedClass::fail(self::class, 'realpath'); + } + + public static function getEnv(string $name) + { + \ShirabeUnsupportedClass::fail(self::class, 'getEnv'); + } + + public static function putEnv(string $name, string $value): void + { + \ShirabeUnsupportedClass::fail(self::class, 'putEnv'); + } + + public static function clearEnv(string $name): void + { + \ShirabeUnsupportedClass::fail(self::class, 'clearEnv'); + } + + public static function expandPath(string $path): string + { + \ShirabeUnsupportedClass::fail(self::class, 'expandPath'); + } + + public static function getUserDirectory(): string + { + \ShirabeUnsupportedClass::fail(self::class, 'getUserDirectory'); + } + + public static function isWindowsSubsystemForLinux(): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'isWindowsSubsystemForLinux'); + } + + public static function isWindows(): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'isWindows'); + } + + public static function isDocker(): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'isDocker'); + } + + public static function strlen(string $str): int + { + \ShirabeUnsupportedClass::fail(self::class, 'strlen'); + } + + public static function isTty($fd = null): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'isTty'); + } + + public static function isInputCompletionProcess(): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'isInputCompletionProcess'); + } + + public static function workaroundFilesystemIssues(): void + { + \ShirabeUnsupportedClass::fail(self::class, 'workaroundFilesystemIssues'); + } + + public static function getDevNull(): string + { + \ShirabeUnsupportedClass::fail(self::class, 'getDevNull'); + } +} diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/ProcessExecutor.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/ProcessExecutor.php new file mode 100644 index 00000000..405905e8 --- /dev/null +++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/ProcessExecutor.php @@ -0,0 +1,114 @@ +<?php + +// Generated by scripts/plugin-stub-generator; do not edit by hand. +// Guard for Composer\Util\ProcessExecutor. +// The Rust side owns this class and the worker has no proxy for it, so this +// declaration shadows the real one: the constants and the hierarchy stay, while +// constructing it or calling anything on it raises an explicit error. + +namespace Composer\Util; + +use Composer\IO\IOInterface; +use React\Promise\PromiseInterface; + +class ProcessExecutor +{ + private const STATUS_QUEUED = 1; + private const STATUS_STARTED = 2; + private const STATUS_COMPLETED = 3; + private const STATUS_FAILED = 4; + private const STATUS_ABORTED = 5; + private const BUILTIN_CMD_COMMANDS = [ + 'assoc', 'break', 'call', 'cd', 'chdir', 'cls', 'color', 'copy', 'date', + 'del', 'dir', 'echo', 'endlocal', 'erase', 'exit', 'for', 'ftype', 'goto', + 'help', 'if', 'label', 'md', 'mkdir', 'mklink', 'move', 'path', 'pause', + 'popd', 'prompt', 'pushd', 'rd', 'rem', 'ren', 'rename', 'rmdir', 'set', + 'setlocal', 'shift', 'start', 'time', 'title', 'type', 'ver', 'vol', + ]; + private const GIT_CMDS_NEED_GIT_DIR = [ + ['show'], + ['log'], + ['branch'], + ['remote', 'set-url'], + ]; + + public function __construct(?IOInterface $io = null) + { + \ShirabeUnsupportedClass::fail(self::class, '__construct'); + } + + public function execute($command, &$output = null, ?string $cwd = null): int + { + \ShirabeUnsupportedClass::fail(self::class, 'execute'); + } + + public function executeTty($command, ?string $cwd = null): int + { + \ShirabeUnsupportedClass::fail(self::class, 'executeTty'); + } + + public function executeAsync($command, ?string $cwd = null): PromiseInterface + { + \ShirabeUnsupportedClass::fail(self::class, 'executeAsync'); + } + + protected function outputHandler(string $type, string $buffer): void + { + \ShirabeUnsupportedClass::fail(self::class, 'outputHandler'); + } + + public function setMaxJobs(int $maxJobs): void + { + \ShirabeUnsupportedClass::fail(self::class, 'setMaxJobs'); + } + + public function resetMaxJobs(): void + { + \ShirabeUnsupportedClass::fail(self::class, 'resetMaxJobs'); + } + + public function wait($index = null): void + { + \ShirabeUnsupportedClass::fail(self::class, 'wait'); + } + + public function enableAsync(): void + { + \ShirabeUnsupportedClass::fail(self::class, 'enableAsync'); + } + + public function countActiveJobs($index = null): int + { + \ShirabeUnsupportedClass::fail(self::class, 'countActiveJobs'); + } + + public function splitLines(?string $output): array + { + \ShirabeUnsupportedClass::fail(self::class, 'splitLines'); + } + + public function getErrorOutput(): string + { + \ShirabeUnsupportedClass::fail(self::class, 'getErrorOutput'); + } + + public static function getTimeout(): int + { + \ShirabeUnsupportedClass::fail(self::class, 'getTimeout'); + } + + public static function setTimeout(int $timeout): void + { + \ShirabeUnsupportedClass::fail(self::class, 'setTimeout'); + } + + public static function escape($argument): string + { + \ShirabeUnsupportedClass::fail(self::class, 'escape'); + } + + public function requiresGitDirEnv($command): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'requiresGitDirEnv'); + } +} diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/RemoteFilesystem.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/RemoteFilesystem.php new file mode 100644 index 00000000..3cf20768 --- /dev/null +++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/RemoteFilesystem.php @@ -0,0 +1,85 @@ +<?php + +// Generated by scripts/plugin-stub-generator; do not edit by hand. +// Guard for Composer\Util\RemoteFilesystem. +// The Rust side owns this class and the worker has no proxy for it, so this +// declaration shadows the real one: the constants and the hierarchy stay, while +// constructing it or calling anything on it raises an explicit error. + +namespace Composer\Util; + +use Composer\Config; +use Composer\IO\IOInterface; + +class RemoteFilesystem +{ + public function __construct(IOInterface $io, Config $config, array $options = [], bool $disableTls = false, ?AuthHelper $authHelper = null) + { + \ShirabeUnsupportedClass::fail(self::class, '__construct'); + } + + public function copy(string $originUrl, string $fileUrl, string $fileName, bool $progress = true, array $options = []) + { + \ShirabeUnsupportedClass::fail(self::class, 'copy'); + } + + public function getContents(string $originUrl, string $fileUrl, bool $progress = true, array $options = []) + { + \ShirabeUnsupportedClass::fail(self::class, 'getContents'); + } + + public function getOptions() + { + \ShirabeUnsupportedClass::fail(self::class, 'getOptions'); + } + + public function setOptions(array $options) + { + \ShirabeUnsupportedClass::fail(self::class, 'setOptions'); + } + + public function isTlsDisabled() + { + \ShirabeUnsupportedClass::fail(self::class, 'isTlsDisabled'); + } + + public function getLastHeaders() + { + \ShirabeUnsupportedClass::fail(self::class, 'getLastHeaders'); + } + + public static function findStatusCode(array $headers) + { + \ShirabeUnsupportedClass::fail(self::class, 'findStatusCode'); + } + + public function findStatusMessage(array $headers) + { + \ShirabeUnsupportedClass::fail(self::class, 'findStatusMessage'); + } + + protected function get(string $originUrl, string $fileUrl, array $additionalOptions = [], ?string $fileName = null, bool $progress = true) + { + \ShirabeUnsupportedClass::fail(self::class, 'get'); + } + + protected function getRemoteContents(string $originUrl, string $fileUrl, $context, ?array &$responseHeaders = null, ?int $maxFileSize = null) + { + \ShirabeUnsupportedClass::fail(self::class, 'getRemoteContents'); + } + + protected function callbackGet(int $notificationCode, int $severity, ?string $message, int $messageCode, int $bytesTransferred, int $bytesMax) + { + \ShirabeUnsupportedClass::fail(self::class, 'callbackGet'); + } + + protected function promptAuthAndRetry($httpStatus, ?string $reason = null, array $headers = []) + { + \ShirabeUnsupportedClass::fail(self::class, 'promptAuthAndRetry'); + } + + protected function getOptionsForUrl(string $originUrl, array $additionalOptions) + { + \ShirabeUnsupportedClass::fail(self::class, 'getOptionsForUrl'); + } +} diff --git a/crates/shirabe-php-rpc/php/guards/Composer/Util/Svn.php b/crates/shirabe-php-rpc/php/guards/Composer/Util/Svn.php new file mode 100644 index 00000000..c113296d --- /dev/null +++ b/crates/shirabe-php-rpc/php/guards/Composer/Util/Svn.php @@ -0,0 +1,82 @@ +<?php + +// Generated by scripts/plugin-stub-generator; do not edit by hand. +// Guard for Composer\Util\Svn. +// The Rust side owns this class and the worker has no proxy for it, so this +// declaration shadows the real one: the constants and the hierarchy stay, while +// constructing it or calling anything on it raises an explicit error. + +namespace Composer\Util; + +use Composer\Config; +use Composer\IO\IOInterface; + +class Svn +{ + private const MAX_QTY_AUTH_TRIES = 5; + + public function __construct(string $url, IOInterface $io, Config $config, ?ProcessExecutor $process = null) + { + \ShirabeUnsupportedClass::fail(self::class, '__construct'); + } + + public static function cleanEnv(): void + { + \ShirabeUnsupportedClass::fail(self::class, 'cleanEnv'); + } + + public function execute(array $command, string $url, ?string $cwd = null, ?string $path = null, bool $verbose = false): string + { + \ShirabeUnsupportedClass::fail(self::class, 'execute'); + } + + public function executeLocal(array $command, string $path, ?string $cwd = null, bool $verbose = false): string + { + \ShirabeUnsupportedClass::fail(self::class, 'executeLocal'); + } + + public function setCacheCredentials(bool $cacheCredentials): void + { + \ShirabeUnsupportedClass::fail(self::class, 'setCacheCredentials'); + } + + protected function doAuthDance(): Svn + { + \ShirabeUnsupportedClass::fail(self::class, 'doAuthDance'); + } + + protected function getCommand(array $cmd, string $url, ?string $path = null): array + { + \ShirabeUnsupportedClass::fail(self::class, 'getCommand'); + } + + protected function getCredentialArgs(): array + { + \ShirabeUnsupportedClass::fail(self::class, 'getCredentialArgs'); + } + + protected function getPassword(): string + { + \ShirabeUnsupportedClass::fail(self::class, 'getPassword'); + } + + protected function getUsername(): string + { + \ShirabeUnsupportedClass::fail(self::class, 'getUsername'); + } + + protected function hasAuth(): bool + { + \ShirabeUnsupportedClass::fail(self::class, 'hasAuth'); + } + + protected function getAuthCacheArgs(): array + { + \ShirabeUnsupportedClass::fail(self::class, 'getAuthCacheArgs'); + } + + public function binaryVersion(): ?string + { + \ShirabeUnsupportedClass::fail(self::class, 'binaryVersion'); + } +} |