summaryrefslogtreecommitdiff
path: root/vendor/php-http/discovery/src
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/php-http/discovery/src')
-rw-r--r--vendor/php-http/discovery/src/ClassDiscovery.php255
-rw-r--r--vendor/php-http/discovery/src/Composer/Plugin.php465
-rw-r--r--vendor/php-http/discovery/src/Exception.php12
-rw-r--r--vendor/php-http/discovery/src/Exception/ClassInstantiationFailedException.php14
-rw-r--r--vendor/php-http/discovery/src/Exception/DiscoveryFailedException.php51
-rw-r--r--vendor/php-http/discovery/src/Exception/NoCandidateFoundException.php47
-rw-r--r--vendor/php-http/discovery/src/Exception/NotFoundException.php16
-rw-r--r--vendor/php-http/discovery/src/Exception/PuliUnavailableException.php12
-rw-r--r--vendor/php-http/discovery/src/Exception/StrategyUnavailableException.php15
-rw-r--r--vendor/php-http/discovery/src/HttpAsyncClientDiscovery.php32
-rw-r--r--vendor/php-http/discovery/src/HttpClientDiscovery.php34
-rw-r--r--vendor/php-http/discovery/src/MessageFactoryDiscovery.php34
-rw-r--r--vendor/php-http/discovery/src/NotFoundException.php14
-rw-r--r--vendor/php-http/discovery/src/Psr17Factory.php303
-rw-r--r--vendor/php-http/discovery/src/Psr17FactoryDiscovery.php136
-rw-r--r--vendor/php-http/discovery/src/Psr18Client.php45
-rw-r--r--vendor/php-http/discovery/src/Psr18ClientDiscovery.php32
-rw-r--r--vendor/php-http/discovery/src/Strategy/CommonClassesStrategy.php180
-rw-r--r--vendor/php-http/discovery/src/Strategy/CommonPsr17ClassesStrategy.php104
-rw-r--r--vendor/php-http/discovery/src/Strategy/DiscoveryStrategy.php23
-rw-r--r--vendor/php-http/discovery/src/Strategy/MockClientStrategy.php24
-rw-r--r--vendor/php-http/discovery/src/Strategy/PuliBetaStrategy.php90
-rw-r--r--vendor/php-http/discovery/src/StreamFactoryDiscovery.php34
-rw-r--r--vendor/php-http/discovery/src/UriFactoryDiscovery.php34
24 files changed, 2006 insertions, 0 deletions
diff --git a/vendor/php-http/discovery/src/ClassDiscovery.php b/vendor/php-http/discovery/src/ClassDiscovery.php
new file mode 100644
index 000000000..5ea469797
--- /dev/null
+++ b/vendor/php-http/discovery/src/ClassDiscovery.php
@@ -0,0 +1,255 @@
+<?php
+
+namespace Http\Discovery;
+
+use Http\Discovery\Exception\ClassInstantiationFailedException;
+use Http\Discovery\Exception\DiscoveryFailedException;
+use Http\Discovery\Exception\NoCandidateFoundException;
+use Http\Discovery\Exception\StrategyUnavailableException;
+use Http\Discovery\Strategy\DiscoveryStrategy;
+
+/**
+ * Registry that based find results on class existence.
+ *
+ * @author David de Boer <[email protected]>
+ * @author Márk Sági-Kazár <[email protected]>
+ * @author Tobias Nyholm <[email protected]>
+ */
+abstract class ClassDiscovery
+{
+ /**
+ * A list of strategies to find classes.
+ *
+ * @var DiscoveryStrategy[]
+ */
+ private static $strategies = [
+ Strategy\GeneratedDiscoveryStrategy::class,
+ Strategy\CommonClassesStrategy::class,
+ Strategy\CommonPsr17ClassesStrategy::class,
+ Strategy\PuliBetaStrategy::class,
+ ];
+
+ private static $deprecatedStrategies = [
+ Strategy\PuliBetaStrategy::class => true,
+ ];
+
+ /**
+ * Discovery cache to make the second time we use discovery faster.
+ *
+ * @var array
+ */
+ private static $cache = [];
+
+ /**
+ * Finds a class.
+ *
+ * @param string $type
+ *
+ * @return string|\Closure
+ *
+ * @throws DiscoveryFailedException
+ */
+ protected static function findOneByType($type)
+ {
+ // Look in the cache
+ if (null !== ($class = self::getFromCache($type))) {
+ return $class;
+ }
+
+ static $skipStrategy;
+ $skipStrategy ?? $skipStrategy = self::safeClassExists(Strategy\GeneratedDiscoveryStrategy::class) ? false : Strategy\GeneratedDiscoveryStrategy::class;
+
+ $exceptions = [];
+ foreach (self::$strategies as $strategy) {
+ if ($skipStrategy === $strategy) {
+ continue;
+ }
+
+ try {
+ $candidates = $strategy::getCandidates($type);
+ } catch (StrategyUnavailableException $e) {
+ if (!isset(self::$deprecatedStrategies[$strategy])) {
+ $exceptions[] = $e;
+ }
+
+ continue;
+ }
+
+ foreach ($candidates as $candidate) {
+ if (isset($candidate['condition'])) {
+ if (!self::evaluateCondition($candidate['condition'])) {
+ continue;
+ }
+ }
+
+ // save the result for later use
+ self::storeInCache($type, $candidate);
+
+ return $candidate['class'];
+ }
+
+ $exceptions[] = new NoCandidateFoundException($strategy, $candidates);
+ }
+
+ throw DiscoveryFailedException::create($exceptions);
+ }
+
+ /**
+ * Get a value from cache.
+ *
+ * @param string $type
+ *
+ * @return string|null
+ */
+ private static function getFromCache($type)
+ {
+ if (!isset(self::$cache[$type])) {
+ return;
+ }
+
+ $candidate = self::$cache[$type];
+ if (isset($candidate['condition'])) {
+ if (!self::evaluateCondition($candidate['condition'])) {
+ return;
+ }
+ }
+
+ return $candidate['class'];
+ }
+
+ /**
+ * Store a value in cache.
+ *
+ * @param string $type
+ * @param string $class
+ */
+ private static function storeInCache($type, $class)
+ {
+ self::$cache[$type] = $class;
+ }
+
+ /**
+ * Set new strategies and clear the cache.
+ *
+ * @param string[] $strategies list of fully qualified class names that implement DiscoveryStrategy
+ */
+ public static function setStrategies(array $strategies)
+ {
+ self::$strategies = $strategies;
+ self::clearCache();
+ }
+
+ /**
+ * Returns the currently configured discovery strategies as fully qualified class names.
+ *
+ * @return string[]
+ */
+ public static function getStrategies(): iterable
+ {
+ return self::$strategies;
+ }
+
+ /**
+ * Append a strategy at the end of the strategy queue.
+ *
+ * @param string $strategy Fully qualified class name of a DiscoveryStrategy
+ */
+ public static function appendStrategy($strategy)
+ {
+ self::$strategies[] = $strategy;
+ self::clearCache();
+ }
+
+ /**
+ * Prepend a strategy at the beginning of the strategy queue.
+ *
+ * @param string $strategy Fully qualified class name to a DiscoveryStrategy
+ */
+ public static function prependStrategy($strategy)
+ {
+ array_unshift(self::$strategies, $strategy);
+ self::clearCache();
+ }
+
+ public static function clearCache()
+ {
+ self::$cache = [];
+ }
+
+ /**
+ * Evaluates conditions to boolean.
+ *
+ * @return bool
+ */
+ protected static function evaluateCondition($condition)
+ {
+ if (is_string($condition)) {
+ // Should be extended for functions, extensions???
+ return self::safeClassExists($condition);
+ }
+ if (is_callable($condition)) {
+ return (bool) $condition();
+ }
+ if (is_bool($condition)) {
+ return $condition;
+ }
+ if (is_array($condition)) {
+ foreach ($condition as $c) {
+ if (false === static::evaluateCondition($c)) {
+ // Immediately stop execution if the condition is false
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Get an instance of the $class.
+ *
+ * @param string|\Closure $class a FQCN of a class or a closure that instantiate the class
+ *
+ * @return object
+ *
+ * @throws ClassInstantiationFailedException
+ */
+ protected static function instantiateClass($class)
+ {
+ try {
+ if (is_string($class)) {
+ return new $class();
+ }
+
+ if (is_callable($class)) {
+ return $class();
+ }
+ } catch (\Exception $e) {
+ throw new ClassInstantiationFailedException('Unexpected exception when instantiating class.', 0, $e);
+ }
+
+ throw new ClassInstantiationFailedException('Could not instantiate class because parameter is neither a callable nor a string');
+ }
+
+ /**
+ * We need a "safe" version of PHP's "class_exists" because Magento has a bug
+ * (or they call it a "feature"). Magento is throwing an exception if you do class_exists()
+ * on a class that ends with "Factory" and if that file does not exits.
+ *
+ * This function catches all potential exceptions and makes sure to always return a boolean.
+ *
+ * @param string $class
+ *
+ * @return bool
+ */
+ public static function safeClassExists($class)
+ {
+ try {
+ return class_exists($class) || interface_exists($class);
+ } catch (\Exception $e) {
+ return false;
+ }
+ }
+}
diff --git a/vendor/php-http/discovery/src/Composer/Plugin.php b/vendor/php-http/discovery/src/Composer/Plugin.php
new file mode 100644
index 000000000..32ef401e3
--- /dev/null
+++ b/vendor/php-http/discovery/src/Composer/Plugin.php
@@ -0,0 +1,465 @@
+<?php
+
+namespace Http\Discovery\Composer;
+
+use Composer\Composer;
+use Composer\DependencyResolver\Pool;
+use Composer\EventDispatcher\EventSubscriberInterface;
+use Composer\Factory;
+use Composer\Installer;
+use Composer\IO\IOInterface;
+use Composer\Json\JsonFile;
+use Composer\Json\JsonManipulator;
+use Composer\Package\Locker;
+use Composer\Package\Version\VersionParser;
+use Composer\Package\Version\VersionSelector;
+use Composer\Plugin\PluginInterface;
+use Composer\Repository\InstalledRepositoryInterface;
+use Composer\Repository\RepositorySet;
+use Composer\Script\Event;
+use Composer\Script\ScriptEvents;
+use Composer\Util\Filesystem;
+use Http\Discovery\ClassDiscovery;
+
+/**
+ * Auto-installs missing implementations.
+ *
+ * When a dependency requires both this package and one of the supported `*-implementation`
+ * virtual packages, this plugin will auto-install a well-known implementation if none is
+ * found. The plugin will first look at already installed packages and figure out the
+ * preferred implementation to install based on the below stickyness rules (or on the first
+ * listed implementation if no rules match.)
+ *
+ * Don't miss updating src/Strategy/Common*Strategy.php when adding a new supported package.
+ *
+ * @author Nicolas Grekas <[email protected]>
+ *
+ * @internal
+ */
+class Plugin implements PluginInterface, EventSubscriberInterface
+{
+ /**
+ * Describes, for every supported virtual implementation, which packages
+ * provide said implementation and which extra dependencies each package
+ * requires to provide the implementation.
+ */
+ private const PROVIDE_RULES = [
+ 'php-http/async-client-implementation' => [
+ 'symfony/http-client:>=6.3' => ['guzzlehttp/promises', 'psr/http-factory-implementation', 'php-http/httplug'],
+ 'symfony/http-client' => ['guzzlehttp/promises', 'php-http/message-factory', 'psr/http-factory-implementation', 'php-http/httplug'],
+ 'php-http/guzzle7-adapter' => [],
+ 'php-http/guzzle6-adapter' => [],
+ 'php-http/curl-client' => [],
+ 'php-http/react-adapter' => [],
+ ],
+ 'php-http/client-implementation' => [
+ 'symfony/http-client:>=6.3' => ['psr/http-factory-implementation', 'php-http/httplug'],
+ 'symfony/http-client' => ['php-http/message-factory', 'psr/http-factory-implementation', 'php-http/httplug'],
+ 'php-http/guzzle7-adapter' => [],
+ 'php-http/guzzle6-adapter' => [],
+ 'php-http/cakephp-adapter' => [],
+ 'php-http/curl-client' => [],
+ 'php-http/react-adapter' => [],
+ 'php-http/buzz-adapter' => [],
+ 'php-http/artax-adapter' => [],
+ 'kriswallsmith/buzz:^1' => [],
+ ],
+ 'psr/http-client-implementation' => [
+ 'symfony/http-client' => ['psr/http-factory-implementation', 'psr/http-client'],
+ 'guzzlehttp/guzzle' => [],
+ 'kriswallsmith/buzz:^1' => [],
+ ],
+ 'psr/http-message-implementation' => [
+ 'php-http/discovery' => ['psr/http-factory-implementation'],
+ ],
+ 'psr/http-factory-implementation' => [
+ 'nyholm/psr7' => [],
+ 'guzzlehttp/psr7:>=2' => [],
+ 'slim/psr7' => [],
+ 'laminas/laminas-diactoros' => [],
+ 'phalcon/cphalcon:^4' => [],
+ 'http-interop/http-factory-guzzle' => [],
+ 'http-interop/http-factory-diactoros' => [],
+ 'http-interop/http-factory-slim' => [],
+ 'httpsoft/http-message' => [],
+ ],
+ ];
+
+ /**
+ * Describes which package should be preferred on the left side
+ * depending on which one is already installed on the right side.
+ */
+ private const STICKYNESS_RULES = [
+ 'symfony/http-client' => 'symfony/framework-bundle',
+ 'php-http/guzzle7-adapter' => 'guzzlehttp/guzzle:^7',
+ 'php-http/guzzle6-adapter' => 'guzzlehttp/guzzle:^6',
+ 'php-http/guzzle5-adapter' => 'guzzlehttp/guzzle:^5',
+ 'php-http/cakephp-adapter' => 'cakephp/cakephp',
+ 'php-http/react-adapter' => 'react/event-loop',
+ 'php-http/buzz-adapter' => 'kriswallsmith/buzz:^0.15.1',
+ 'php-http/artax-adapter' => 'amphp/artax:^3',
+ 'http-interop/http-factory-guzzle' => 'guzzlehttp/psr7:^1',
+ 'http-interop/http-factory-slim' => 'slim/slim:^3',
+ ];
+
+ private const INTERFACE_MAP = [
+ 'php-http/async-client-implementation' => [
+ 'Http\Client\HttpAsyncClient',
+ ],
+ 'php-http/client-implementation' => [
+ 'Http\Client\HttpClient',
+ ],
+ 'psr/http-client-implementation' => [
+ 'Psr\Http\Client\ClientInterface',
+ ],
+ 'psr/http-factory-implementation' => [
+ 'Psr\Http\Message\RequestFactoryInterface',
+ 'Psr\Http\Message\ResponseFactoryInterface',
+ 'Psr\Http\Message\ServerRequestFactoryInterface',
+ 'Psr\Http\Message\StreamFactoryInterface',
+ 'Psr\Http\Message\UploadedFileFactoryInterface',
+ 'Psr\Http\Message\UriFactoryInterface',
+ ],
+ ];
+
+ public static function getSubscribedEvents(): array
+ {
+ return [
+ ScriptEvents::PRE_AUTOLOAD_DUMP => 'preAutoloadDump',
+ ScriptEvents::POST_UPDATE_CMD => 'postUpdate',
+ ];
+ }
+
+ public function activate(Composer $composer, IOInterface $io): void
+ {
+ }
+
+ public function deactivate(Composer $composer, IOInterface $io)
+ {
+ }
+
+ public function uninstall(Composer $composer, IOInterface $io)
+ {
+ }
+
+ public function postUpdate(Event $event)
+ {
+ $composer = $event->getComposer();
+ $repo = $composer->getRepositoryManager()->getLocalRepository();
+ $requires = [
+ $composer->getPackage()->getRequires(),
+ $composer->getPackage()->getDevRequires(),
+ ];
+ $pinnedAbstractions = [];
+ $pinned = $composer->getPackage()->getExtra()['discovery'] ?? [];
+ foreach (self::INTERFACE_MAP as $abstraction => $interfaces) {
+ foreach (isset($pinned[$abstraction]) ? [] : $interfaces as $interface) {
+ if (!isset($pinned[$interface])) {
+ continue 2;
+ }
+ }
+ $pinnedAbstractions[$abstraction] = true;
+ }
+
+ $missingRequires = $this->getMissingRequires($repo, $requires, 'project' === $composer->getPackage()->getType(), $pinnedAbstractions);
+ $missingRequires = [
+ 'require' => array_fill_keys(array_merge([], ...array_values($missingRequires[0])), '*'),
+ 'require-dev' => array_fill_keys(array_merge([], ...array_values($missingRequires[1])), '*'),
+ 'remove' => array_fill_keys(array_merge([], ...array_values($missingRequires[2])), '*'),
+ ];
+
+ if (!$missingRequires = array_filter($missingRequires)) {
+ return;
+ }
+
+ $composerJsonContents = file_get_contents(Factory::getComposerFile());
+ $this->updateComposerJson($missingRequires, $composer->getConfig()->get('sort-packages'));
+
+ $installer = null;
+ // Find the composer installer, hack borrowed from symfony/flex
+ foreach (debug_backtrace(\DEBUG_BACKTRACE_PROVIDE_OBJECT) as $trace) {
+ if (isset($trace['object']) && $trace['object'] instanceof Installer) {
+ $installer = $trace['object'];
+ break;
+ }
+ }
+
+ if (!$installer) {
+ return;
+ }
+
+ $event->stopPropagation();
+
+ $dispatcher = $composer->getEventDispatcher();
+ $disableScripts = !method_exists($dispatcher, 'setRunScripts') || !((array) $dispatcher)["\0*\0runScripts"];
+ $composer = Factory::create($event->getIO(), null, false, $disableScripts);
+
+ /** @var Installer $installer */
+ $installer = clone $installer;
+ if (method_exists($installer, 'setAudit')) {
+ $trace['object']->setAudit(false);
+ }
+ // we need a clone of the installer to preserve its configuration state but with our own service objects
+ $installer->__construct(
+ $event->getIO(),
+ $composer->getConfig(),
+ $composer->getPackage(),
+ $composer->getDownloadManager(),
+ $composer->getRepositoryManager(),
+ $composer->getLocker(),
+ $composer->getInstallationManager(),
+ $composer->getEventDispatcher(),
+ $composer->getAutoloadGenerator()
+ );
+ if (method_exists($installer, 'setPlatformRequirementFilter')) {
+ $installer->setPlatformRequirementFilter(((array) $trace['object'])["\0*\0platformRequirementFilter"]);
+ }
+
+ if (0 !== $installer->run()) {
+ file_put_contents(Factory::getComposerFile(), $composerJsonContents);
+
+ return;
+ }
+
+ $versionSelector = new VersionSelector(ClassDiscovery::safeClassExists(RepositorySet::class) ? new RepositorySet() : new Pool());
+ $updateComposerJson = false;
+
+ foreach ($composer->getRepositoryManager()->getLocalRepository()->getPackages() as $package) {
+ foreach (['require', 'require-dev'] as $key) {
+ if (!isset($missingRequires[$key][$package->getName()])) {
+ continue;
+ }
+ $updateComposerJson = true;
+ $missingRequires[$key][$package->getName()] = $versionSelector->findRecommendedRequireVersion($package);
+ }
+ }
+
+ if ($updateComposerJson) {
+ $this->updateComposerJson($missingRequires, $composer->getConfig()->get('sort-packages'));
+ $this->updateComposerLock($composer, $event->getIO());
+ }
+ }
+
+ public function getMissingRequires(InstalledRepositoryInterface $repo, array $requires, bool $isProject, array $pinnedAbstractions): array
+ {
+ $allPackages = [];
+ $devPackages = method_exists($repo, 'getDevPackageNames') ? array_fill_keys($repo->getDevPackageNames(), true) : [];
+
+ // One must require "php-http/discovery"
+ // to opt-in for auto-installation of virtual package implementations
+ if (!isset($requires[0]['php-http/discovery'])) {
+ $requires = [[], []];
+ }
+
+ foreach ($repo->getPackages() as $package) {
+ $allPackages[$package->getName()] = true;
+
+ if (1 < \count($names = $package->getNames(false))) {
+ $allPackages += array_fill_keys($names, false);
+
+ if (isset($devPackages[$package->getName()])) {
+ $devPackages += $names;
+ }
+ }
+
+ if (isset($package->getRequires()['php-http/discovery'])) {
+ $requires[(int) isset($devPackages[$package->getName()])] += $package->getRequires();
+ }
+ }
+
+ $missingRequires = [[], [], []];
+ $versionParser = new VersionParser();
+
+ if (ClassDiscovery::safeClassExists(\Phalcon\Http\Message\RequestFactory::class, false)) {
+ $missingRequires[0]['psr/http-factory-implementation'] = [];
+ $missingRequires[1]['psr/http-factory-implementation'] = [];
+ }
+
+ foreach ($requires as $dev => $rules) {
+ $abstractions = [];
+ $rules = array_intersect_key(self::PROVIDE_RULES, $rules);
+
+ while ($rules) {
+ $abstraction = key($rules);
+
+ if (isset($pinnedAbstractions[$abstraction])) {
+ unset($rules[$abstraction]);
+ continue;
+ }
+
+ $abstractions[] = $abstraction;
+
+ foreach (array_shift($rules) as $candidate => $deps) {
+ [$candidate, $version] = explode(':', $candidate, 2) + [1 => null];
+
+ if (!isset($allPackages[$candidate])) {
+ continue;
+ }
+ if (null !== $version && !$repo->findPackage($candidate, $versionParser->parseConstraints($version))) {
+ continue;
+ }
+ if ($isProject && !$dev && isset($devPackages[$candidate])) {
+ $missingRequires[0][$abstraction] = [$candidate];
+ $missingRequires[2][$abstraction] = [$candidate];
+ } else {
+ $missingRequires[$dev][$abstraction] = [];
+ }
+
+ foreach ($deps as $dep) {
+ if (isset(self::PROVIDE_RULES[$dep])) {
+ $rules[$dep] = self::PROVIDE_RULES[$dep];
+ } elseif (!isset($allPackages[$dep])) {
+ $missingRequires[$dev][$abstraction][] = $dep;
+ } elseif ($isProject && !$dev && isset($devPackages[$dep])) {
+ $missingRequires[0][$abstraction][] = $dep;
+ $missingRequires[2][$abstraction][] = $dep;
+ }
+ }
+ break;
+ }
+ }
+
+ while ($abstractions) {
+ $abstraction = array_shift($abstractions);
+
+ if (isset($missingRequires[$dev][$abstraction])) {
+ continue;
+ }
+ $candidates = self::PROVIDE_RULES[$abstraction];
+
+ foreach ($candidates as $candidate => $deps) {
+ [$candidate, $version] = explode(':', $candidate, 2) + [1 => null];
+
+ if (null !== $version && !$repo->findPackage($candidate, $versionParser->parseConstraints($version))) {
+ continue;
+ }
+ if (isset($allPackages[$candidate]) && (!$isProject || $dev || !isset($devPackages[$candidate]))) {
+ continue 2;
+ }
+ }
+
+ foreach (array_intersect_key(self::STICKYNESS_RULES, $candidates) as $candidate => $stickyRule) {
+ [$stickyName, $stickyVersion] = explode(':', $stickyRule, 2) + [1 => null];
+ if (!isset($allPackages[$stickyName]) || ($isProject && !$dev && isset($devPackages[$stickyName]))) {
+ continue;
+ }
+ if (null !== $stickyVersion && !$repo->findPackage($stickyName, $versionParser->parseConstraints($stickyVersion))) {
+ continue;
+ }
+
+ $candidates = [$candidate => $candidates[$candidate]];
+ break;
+ }
+
+ $dep = key($candidates);
+ [$dep] = explode(':', $dep, 2);
+ $missingRequires[$dev][$abstraction] = [$dep];
+
+ if ($isProject && !$dev && isset($devPackages[$dep])) {
+ $missingRequires[2][$abstraction][] = $dep;
+ }
+ }
+ }
+
+ $missingRequires[1] = array_diff_key($missingRequires[1], $missingRequires[0]);
+
+ return $missingRequires;
+ }
+
+ public function preAutoloadDump(Event $event)
+ {
+ $filesystem = new Filesystem();
+ // Double realpath() on purpose, see https://bugs.php.net/72738
+ $vendorDir = $filesystem->normalizePath(realpath(realpath($event->getComposer()->getConfig()->get('vendor-dir'))));
+ $filesystem->ensureDirectoryExists($vendorDir.'/composer');
+ $pinned = $event->getComposer()->getPackage()->getExtra()['discovery'] ?? [];
+ $candidates = [];
+
+ $allInterfaces = array_merge(...array_values(self::INTERFACE_MAP));
+ foreach ($pinned as $abstraction => $class) {
+ if (isset(self::INTERFACE_MAP[$abstraction])) {
+ $interfaces = self::INTERFACE_MAP[$abstraction];
+ } elseif (false !== $k = array_search($abstraction, $allInterfaces, true)) {
+ $interfaces = [$allInterfaces[$k]];
+ } else {
+ throw new \UnexpectedValueException(sprintf('Invalid "extra.discovery" pinned in composer.json: "%s" is not one of ["%s"].', $abstraction, implode('", "', array_keys(self::INTERFACE_MAP))));
+ }
+
+ foreach ($interfaces as $interface) {
+ $candidates[] = sprintf("case %s: return [['class' => %s]];\n", var_export($interface, true), var_export($class, true));
+ }
+ }
+
+ $file = $vendorDir.'/composer/GeneratedDiscoveryStrategy.php';
+
+ if (!$candidates) {
+ if (file_exists($file)) {
+ unlink($file);
+ }
+
+ return;
+ }
+
+ $candidates = implode(' ', $candidates);
+ $code = <<<EOPHP
+<?php
+
+namespace Http\Discovery\Strategy;
+
+class GeneratedDiscoveryStrategy implements DiscoveryStrategy
+{
+ public static function getCandidates(\$type)
+ {
+ switch (\$type) {
+ $candidates
+ default: return [];
+ }
+ }
+}
+
+EOPHP
+ ;
+
+ if (!file_exists($file) || $code !== file_get_contents($file)) {
+ file_put_contents($file, $code);
+ }
+
+ $rootPackage = $event->getComposer()->getPackage();
+ $autoload = $rootPackage->getAutoload();
+ $autoload['classmap'][] = $vendorDir.'/composer/GeneratedDiscoveryStrategy.php';
+ $rootPackage->setAutoload($autoload);
+ }
+
+ private function updateComposerJson(array $missingRequires, bool $sortPackages)
+ {
+ $file = Factory::getComposerFile();
+ $contents = file_get_contents($file);
+
+ $manipulator = new JsonManipulator($contents);
+
+ foreach ($missingRequires as $key => $packages) {
+ foreach ($packages as $package => $constraint) {
+ if ('remove' === $key) {
+ $manipulator->removeSubNode('require-dev', $package);
+ } else {
+ $manipulator->addLink($key, $package, $constraint, $sortPackages);
+ }
+ }
+ }
+
+ file_put_contents($file, $manipulator->getContents());
+ }
+
+ private function updateComposerLock(Composer $composer, IOInterface $io)
+ {
+ $lock = substr(Factory::getComposerFile(), 0, -4).'lock';
+ $composerJson = file_get_contents(Factory::getComposerFile());
+ $lockFile = new JsonFile($lock, null, $io);
+ $locker = ClassDiscovery::safeClassExists(RepositorySet::class)
+ ? new Locker($io, $lockFile, $composer->getInstallationManager(), $composerJson)
+ : new Locker($io, $lockFile, $composer->getRepositoryManager(), $composer->getInstallationManager(), $composerJson);
+ $lockData = $locker->getLockData();
+ $lockData['content-hash'] = Locker::getContentHash($composerJson);
+ $lockFile->write($lockData);
+ }
+}
diff --git a/vendor/php-http/discovery/src/Exception.php b/vendor/php-http/discovery/src/Exception.php
new file mode 100644
index 000000000..0fa8c767e
--- /dev/null
+++ b/vendor/php-http/discovery/src/Exception.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace Http\Discovery;
+
+/**
+ * An interface implemented by all discovery related exceptions.
+ *
+ * @author Tobias Nyholm <[email protected]>
+ */
+interface Exception extends \Throwable
+{
+}
diff --git a/vendor/php-http/discovery/src/Exception/ClassInstantiationFailedException.php b/vendor/php-http/discovery/src/Exception/ClassInstantiationFailedException.php
new file mode 100644
index 000000000..e95bf5d82
--- /dev/null
+++ b/vendor/php-http/discovery/src/Exception/ClassInstantiationFailedException.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace Http\Discovery\Exception;
+
+use Http\Discovery\Exception;
+
+/**
+ * Thrown when a class fails to instantiate.
+ *
+ * @author Tobias Nyholm <[email protected]>
+ */
+final class ClassInstantiationFailedException extends \RuntimeException implements Exception
+{
+}
diff --git a/vendor/php-http/discovery/src/Exception/DiscoveryFailedException.php b/vendor/php-http/discovery/src/Exception/DiscoveryFailedException.php
new file mode 100644
index 000000000..304b7276e
--- /dev/null
+++ b/vendor/php-http/discovery/src/Exception/DiscoveryFailedException.php
@@ -0,0 +1,51 @@
+<?php
+
+namespace Http\Discovery\Exception;
+
+use Http\Discovery\Exception;
+
+/**
+ * Thrown when all discovery strategies fails to find a resource.
+ *
+ * @author Tobias Nyholm <[email protected]>
+ */
+final class DiscoveryFailedException extends \Exception implements Exception
+{
+ /**
+ * @var \Exception[]
+ */
+ private $exceptions;
+
+ /**
+ * @param string $message
+ * @param \Exception[] $exceptions
+ */
+ public function __construct($message, array $exceptions = [])
+ {
+ $this->exceptions = $exceptions;
+
+ parent::__construct($message);
+ }
+
+ /**
+ * @param \Exception[] $exceptions
+ */
+ public static function create($exceptions)
+ {
+ $message = 'Could not find resource using any discovery strategy. Find more information at http://docs.php-http.org/en/latest/discovery.html#common-errors';
+ foreach ($exceptions as $e) {
+ $message .= "\n - ".$e->getMessage();
+ }
+ $message .= "\n\n";
+
+ return new self($message, $exceptions);
+ }
+
+ /**
+ * @return \Exception[]
+ */
+ public function getExceptions()
+ {
+ return $this->exceptions;
+ }
+}
diff --git a/vendor/php-http/discovery/src/Exception/NoCandidateFoundException.php b/vendor/php-http/discovery/src/Exception/NoCandidateFoundException.php
new file mode 100644
index 000000000..32f65db7b
--- /dev/null
+++ b/vendor/php-http/discovery/src/Exception/NoCandidateFoundException.php
@@ -0,0 +1,47 @@
+<?php
+
+namespace Http\Discovery\Exception;
+
+use Http\Discovery\Exception;
+
+/**
+ * When we have used a strategy but no candidates provided by that strategy could be used.
+ *
+ * @author Tobias Nyholm <[email protected]>
+ */
+final class NoCandidateFoundException extends \Exception implements Exception
+{
+ /**
+ * @param string $strategy
+ */
+ public function __construct($strategy, array $candidates)
+ {
+ $classes = array_map(
+ function ($a) {
+ return $a['class'];
+ },
+ $candidates
+ );
+
+ $message = sprintf(
+ 'No valid candidate found using strategy "%s". We tested the following candidates: %s.',
+ $strategy,
+ implode(', ', array_map([$this, 'stringify'], $classes))
+ );
+
+ parent::__construct($message);
+ }
+
+ private function stringify($mixed)
+ {
+ if (is_string($mixed)) {
+ return $mixed;
+ }
+
+ if (is_array($mixed) && 2 === count($mixed)) {
+ return sprintf('%s::%s', $this->stringify($mixed[0]), $mixed[1]);
+ }
+
+ return is_object($mixed) ? get_class($mixed) : gettype($mixed);
+ }
+}
diff --git a/vendor/php-http/discovery/src/Exception/NotFoundException.php b/vendor/php-http/discovery/src/Exception/NotFoundException.php
new file mode 100644
index 000000000..ef8b9c584
--- /dev/null
+++ b/vendor/php-http/discovery/src/Exception/NotFoundException.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace Http\Discovery\Exception;
+
+use Http\Discovery\Exception;
+
+/**
+ * Thrown when a discovery does not find any matches.
+ *
+ * @final do NOT extend this class, not final for BC reasons
+ *
+ * @author Márk Sági-Kazár <[email protected]>
+ */
+/* final */ class NotFoundException extends \RuntimeException implements Exception
+{
+}
diff --git a/vendor/php-http/discovery/src/Exception/PuliUnavailableException.php b/vendor/php-http/discovery/src/Exception/PuliUnavailableException.php
new file mode 100644
index 000000000..a6ade7332
--- /dev/null
+++ b/vendor/php-http/discovery/src/Exception/PuliUnavailableException.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace Http\Discovery\Exception;
+
+/**
+ * Thrown when we can't use Puli for discovery.
+ *
+ * @author Tobias Nyholm <[email protected]>
+ */
+final class PuliUnavailableException extends StrategyUnavailableException
+{
+}
diff --git a/vendor/php-http/discovery/src/Exception/StrategyUnavailableException.php b/vendor/php-http/discovery/src/Exception/StrategyUnavailableException.php
new file mode 100644
index 000000000..89ecf3523
--- /dev/null
+++ b/vendor/php-http/discovery/src/Exception/StrategyUnavailableException.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Http\Discovery\Exception;
+
+use Http\Discovery\Exception;
+
+/**
+ * This exception is thrown when we cannot use a discovery strategy. This is *not* thrown when
+ * the discovery fails to find a class.
+ *
+ * @author Tobias Nyholm <[email protected]>
+ */
+class StrategyUnavailableException extends \RuntimeException implements Exception
+{
+}
diff --git a/vendor/php-http/discovery/src/HttpAsyncClientDiscovery.php b/vendor/php-http/discovery/src/HttpAsyncClientDiscovery.php
new file mode 100644
index 000000000..a0c4d5b7c
--- /dev/null
+++ b/vendor/php-http/discovery/src/HttpAsyncClientDiscovery.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace Http\Discovery;
+
+use Http\Client\HttpAsyncClient;
+use Http\Discovery\Exception\DiscoveryFailedException;
+
+/**
+ * Finds an HTTP Asynchronous Client.
+ *
+ * @author Joel Wurtz <[email protected]>
+ */
+final class HttpAsyncClientDiscovery extends ClassDiscovery
+{
+ /**
+ * Finds an HTTP Async Client.
+ *
+ * @return HttpAsyncClient
+ *
+ * @throws Exception\NotFoundException
+ */
+ public static function find()
+ {
+ try {
+ $asyncClient = static::findOneByType(HttpAsyncClient::class);
+ } catch (DiscoveryFailedException $e) {
+ throw new NotFoundException('No HTTPlug async clients found. Make sure to install a package providing "php-http/async-client-implementation". Example: "php-http/guzzle6-adapter".', 0, $e);
+ }
+
+ return static::instantiateClass($asyncClient);
+ }
+}
diff --git a/vendor/php-http/discovery/src/HttpClientDiscovery.php b/vendor/php-http/discovery/src/HttpClientDiscovery.php
new file mode 100644
index 000000000..2501e5bbf
--- /dev/null
+++ b/vendor/php-http/discovery/src/HttpClientDiscovery.php
@@ -0,0 +1,34 @@
+<?php
+
+namespace Http\Discovery;
+
+use Http\Client\HttpClient;
+use Http\Discovery\Exception\DiscoveryFailedException;
+
+/**
+ * Finds an HTTP Client.
+ *
+ * @author Márk Sági-Kazár <[email protected]>
+ *
+ * @deprecated This will be removed in 2.0. Consider using Psr18ClientDiscovery.
+ */
+final class HttpClientDiscovery extends ClassDiscovery
+{
+ /**
+ * Finds an HTTP Client.
+ *
+ * @return HttpClient
+ *
+ * @throws Exception\NotFoundException
+ */
+ public static function find()
+ {
+ try {
+ $client = static::findOneByType(HttpClient::class);
+ } catch (DiscoveryFailedException $e) {
+ throw new NotFoundException('No HTTPlug clients found. Make sure to install a package providing "php-http/client-implementation". Example: "php-http/guzzle6-adapter".', 0, $e);
+ }
+
+ return static::instantiateClass($client);
+ }
+}
diff --git a/vendor/php-http/discovery/src/MessageFactoryDiscovery.php b/vendor/php-http/discovery/src/MessageFactoryDiscovery.php
new file mode 100644
index 000000000..4ae104aa6
--- /dev/null
+++ b/vendor/php-http/discovery/src/MessageFactoryDiscovery.php
@@ -0,0 +1,34 @@
+<?php
+
+namespace Http\Discovery;
+
+use Http\Discovery\Exception\DiscoveryFailedException;
+use Http\Message\MessageFactory;
+
+/**
+ * Finds a Message Factory.
+ *
+ * @author Márk Sági-Kazár <[email protected]>
+ *
+ * @deprecated This will be removed in 2.0. Consider using Psr17FactoryDiscovery.
+ */
+final class MessageFactoryDiscovery extends ClassDiscovery
+{
+ /**
+ * Finds a Message Factory.
+ *
+ * @return MessageFactory
+ *
+ * @throws Exception\NotFoundException
+ */
+ public static function find()
+ {
+ try {
+ $messageFactory = static::findOneByType(MessageFactory::class);
+ } catch (DiscoveryFailedException $e) {
+ throw new NotFoundException('No php-http message factories found. Note that the php-http message factories are deprecated in favor of the PSR-17 message factories. To use the legacy Guzzle, Diactoros or Slim Framework factories of php-http, install php-http/message and php-http/message-factory and the chosen message implementation.', 0, $e);
+ }
+
+ return static::instantiateClass($messageFactory);
+ }
+}
diff --git a/vendor/php-http/discovery/src/NotFoundException.php b/vendor/php-http/discovery/src/NotFoundException.php
new file mode 100644
index 000000000..d59dadbf8
--- /dev/null
+++ b/vendor/php-http/discovery/src/NotFoundException.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace Http\Discovery;
+
+/**
+ * Thrown when a discovery does not find any matches.
+ *
+ * @author Márk Sági-Kazár <[email protected]>
+ *
+ * @deprecated since since version 1.0, and will be removed in 2.0. Use {@link \Http\Discovery\Exception\NotFoundException} instead.
+ */
+final class NotFoundException extends \Http\Discovery\Exception\NotFoundException
+{
+}
diff --git a/vendor/php-http/discovery/src/Psr17Factory.php b/vendor/php-http/discovery/src/Psr17Factory.php
new file mode 100644
index 000000000..5d3ab9273
--- /dev/null
+++ b/vendor/php-http/discovery/src/Psr17Factory.php
@@ -0,0 +1,303 @@
+<?php
+
+namespace Http\Discovery;
+
+use Psr\Http\Message\RequestFactoryInterface;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseFactoryInterface;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestFactoryInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Message\StreamFactoryInterface;
+use Psr\Http\Message\StreamInterface;
+use Psr\Http\Message\UploadedFileFactoryInterface;
+use Psr\Http\Message\UploadedFileInterface;
+use Psr\Http\Message\UriFactoryInterface;
+use Psr\Http\Message\UriInterface;
+
+/**
+ * A generic PSR-17 implementation.
+ *
+ * You can create this class with concrete factory instances or let
+ * it use discovery to find suitable implementations as needed.
+ *
+ * This class also provides two additional methods that are not in PSR17,
+ * to help with creating PSR-7 objects from PHP superglobals:
+ * - createServerRequestFromGlobals()
+ * - createUriFromGlobals()
+ *
+ * The code in this class is inspired by the "nyholm/psr7", "guzzlehttp/psr7"
+ * and "symfony/http-foundation" packages, all licenced under MIT.
+ *
+ * Copyright (c) 2004-2023 Fabien Potencier <[email protected]>
+ * Copyright (c) 2015 Michael Dowling <[email protected]>
+ * Copyright (c) 2015 Márk Sági-Kazár <[email protected]>
+ * Copyright (c) 2015 Graham Campbell <[email protected]>
+ * Copyright (c) 2016 Tobias Schultze <[email protected]>
+ * Copyright (c) 2016 George Mponos <[email protected]>
+ * Copyright (c) 2016-2018 Tobias Nyholm <[email protected]>
+ *
+ * @author Nicolas Grekas <[email protected]>
+ */
+class Psr17Factory implements RequestFactoryInterface, ResponseFactoryInterface, ServerRequestFactoryInterface, StreamFactoryInterface, UploadedFileFactoryInterface, UriFactoryInterface
+{
+ private $requestFactory;
+ private $responseFactory;
+ private $serverRequestFactory;
+ private $streamFactory;
+ private $uploadedFileFactory;
+ private $uriFactory;
+
+ public function __construct(
+ RequestFactoryInterface $requestFactory = null,
+ ResponseFactoryInterface $responseFactory = null,
+ ServerRequestFactoryInterface $serverRequestFactory = null,
+ StreamFactoryInterface $streamFactory = null,
+ UploadedFileFactoryInterface $uploadedFileFactory = null,
+ UriFactoryInterface $uriFactory = null
+ ) {
+ $this->requestFactory = $requestFactory;
+ $this->responseFactory = $responseFactory;
+ $this->serverRequestFactory = $serverRequestFactory;
+ $this->streamFactory = $streamFactory;
+ $this->uploadedFileFactory = $uploadedFileFactory;
+ $this->uriFactory = $uriFactory;
+
+ $this->setFactory($requestFactory);
+ $this->setFactory($responseFactory);
+ $this->setFactory($serverRequestFactory);
+ $this->setFactory($streamFactory);
+ $this->setFactory($uploadedFileFactory);
+ $this->setFactory($uriFactory);
+ }
+
+ /**
+ * @param UriInterface|string $uri
+ */
+ public function createRequest(string $method, $uri): RequestInterface
+ {
+ $factory = $this->requestFactory ?? $this->setFactory(Psr17FactoryDiscovery::findRequestFactory());
+
+ return $factory->createRequest(...\func_get_args());
+ }
+
+ public function createResponse(int $code = 200, string $reasonPhrase = ''): ResponseInterface
+ {
+ $factory = $this->responseFactory ?? $this->setFactory(Psr17FactoryDiscovery::findResponseFactory());
+
+ return $factory->createResponse(...\func_get_args());
+ }
+
+ /**
+ * @param UriInterface|string $uri
+ */
+ public function createServerRequest(string $method, $uri, array $serverParams = []): ServerRequestInterface
+ {
+ $factory = $this->serverRequestFactory ?? $this->setFactory(Psr17FactoryDiscovery::findServerRequestFactory());
+
+ return $factory->createServerRequest(...\func_get_args());
+ }
+
+ public function createServerRequestFromGlobals(array $server = null, array $get = null, array $post = null, array $cookie = null, array $files = null, StreamInterface $body = null): ServerRequestInterface
+ {
+ $server = $server ?? $_SERVER;
+ $request = $this->createServerRequest($server['REQUEST_METHOD'] ?? 'GET', $this->createUriFromGlobals($server), $server);
+
+ return $this->buildServerRequestFromGlobals($request, $server, $files ?? $_FILES)
+ ->withQueryParams($get ?? $_GET)
+ ->withParsedBody($post ?? $_POST)
+ ->withCookieParams($cookie ?? $_COOKIE)
+ ->withBody($body ?? $this->createStreamFromFile('php://input', 'r+'));
+ }
+
+ public function createStream(string $content = ''): StreamInterface
+ {
+ $factory = $this->streamFactory ?? $this->setFactory(Psr17FactoryDiscovery::findStreamFactory());
+
+ return $factory->createStream($content);
+ }
+
+ public function createStreamFromFile(string $filename, string $mode = 'r'): StreamInterface
+ {
+ $factory = $this->streamFactory ?? $this->setFactory(Psr17FactoryDiscovery::findStreamFactory());
+
+ return $factory->createStreamFromFile($filename, $mode);
+ }
+
+ /**
+ * @param resource $resource
+ */
+ public function createStreamFromResource($resource): StreamInterface
+ {
+ $factory = $this->streamFactory ?? $this->setFactory(Psr17FactoryDiscovery::findStreamFactory());
+
+ return $factory->createStreamFromResource($resource);
+ }
+
+ public function createUploadedFile(StreamInterface $stream, int $size = null, int $error = \UPLOAD_ERR_OK, string $clientFilename = null, string $clientMediaType = null): UploadedFileInterface
+ {
+ $factory = $this->uploadedFileFactory ?? $this->setFactory(Psr17FactoryDiscovery::findUploadedFileFactory());
+
+ return $factory->createUploadedFile(...\func_get_args());
+ }
+
+ public function createUri(string $uri = ''): UriInterface
+ {
+ $factory = $this->uriFactory ?? $this->setFactory(Psr17FactoryDiscovery::findUriFactory());
+
+ return $factory->createUri(...\func_get_args());
+ }
+
+ public function createUriFromGlobals(array $server = null): UriInterface
+ {
+ return $this->buildUriFromGlobals($this->createUri(''), $server ?? $_SERVER);
+ }
+
+ private function setFactory($factory)
+ {
+ if (!$this->requestFactory && $factory instanceof RequestFactoryInterface) {
+ $this->requestFactory = $factory;
+ }
+ if (!$this->responseFactory && $factory instanceof ResponseFactoryInterface) {
+ $this->responseFactory = $factory;
+ }
+ if (!$this->serverRequestFactory && $factory instanceof ServerRequestFactoryInterface) {
+ $this->serverRequestFactory = $factory;
+ }
+ if (!$this->streamFactory && $factory instanceof StreamFactoryInterface) {
+ $this->streamFactory = $factory;
+ }
+ if (!$this->uploadedFileFactory && $factory instanceof UploadedFileFactoryInterface) {
+ $this->uploadedFileFactory = $factory;
+ }
+ if (!$this->uriFactory && $factory instanceof UriFactoryInterface) {
+ $this->uriFactory = $factory;
+ }
+
+ return $factory;
+ }
+
+ private function buildServerRequestFromGlobals(ServerRequestInterface $request, array $server, array $files): ServerRequestInterface
+ {
+ $request = $request
+ ->withProtocolVersion(isset($server['SERVER_PROTOCOL']) ? str_replace('HTTP/', '', $server['SERVER_PROTOCOL']) : '1.1')
+ ->withUploadedFiles($this->normalizeFiles($files));
+
+ $headers = [];
+ foreach ($server as $k => $v) {
+ if (0 === strpos($k, 'HTTP_')) {
+ $k = substr($k, 5);
+ } elseif (!\in_array($k, ['CONTENT_TYPE', 'CONTENT_LENGTH', 'CONTENT_MD5'], true)) {
+ continue;
+ }
+ $k = str_replace(' ', '-', ucwords(strtolower(str_replace('_', ' ', $k))));
+
+ $headers[$k] = $v;
+ }
+
+ if (!isset($headers['Authorization'])) {
+ if (isset($_SERVER['REDIRECT_HTTP_AUTHORIZATION'])) {
+ $headers['Authorization'] = $_SERVER['REDIRECT_HTTP_AUTHORIZATION'];
+ } elseif (isset($_SERVER['PHP_AUTH_USER'])) {
+ $headers['Authorization'] = 'Basic '.base64_encode($_SERVER['PHP_AUTH_USER'].':'.($_SERVER['PHP_AUTH_PW'] ?? ''));
+ } elseif (isset($_SERVER['PHP_AUTH_DIGEST'])) {
+ $headers['Authorization'] = $_SERVER['PHP_AUTH_DIGEST'];
+ }
+ }
+
+ foreach ($headers as $k => $v) {
+ try {
+ $request = $request->withHeader($k, $v);
+ } catch (\InvalidArgumentException $e) {
+ // ignore invalid headers
+ }
+ }
+
+ return $request;
+ }
+
+ private function buildUriFromGlobals(UriInterface $uri, array $server): UriInterface
+ {
+ $uri = $uri->withScheme(!empty($server['HTTPS']) && 'off' !== strtolower($server['HTTPS']) ? 'https' : 'http');
+
+ $hasPort = false;
+ if (isset($server['HTTP_HOST'])) {
+ $parts = parse_url('http://'.$server['HTTP_HOST']);
+
+ $uri = $uri->withHost($parts['host'] ?? 'localhost');
+
+ if ($parts['port'] ?? false) {
+ $hasPort = true;
+ $uri = $uri->withPort($parts['port']);
+ }
+ } else {
+ $uri = $uri->withHost($server['SERVER_NAME'] ?? $server['SERVER_ADDR'] ?? 'localhost');
+ }
+
+ if (!$hasPort && isset($server['SERVER_PORT'])) {
+ $uri = $uri->withPort($server['SERVER_PORT']);
+ }
+
+ $hasQuery = false;
+ if (isset($server['REQUEST_URI'])) {
+ $requestUriParts = explode('?', $server['REQUEST_URI'], 2);
+ $uri = $uri->withPath($requestUriParts[0]);
+ if (isset($requestUriParts[1])) {
+ $hasQuery = true;
+ $uri = $uri->withQuery($requestUriParts[1]);
+ }
+ }
+
+ if (!$hasQuery && isset($server['QUERY_STRING'])) {
+ $uri = $uri->withQuery($server['QUERY_STRING']);
+ }
+
+ return $uri;
+ }
+
+ private function normalizeFiles(array $files): array
+ {
+ foreach ($files as $k => $v) {
+ if ($v instanceof UploadedFileInterface) {
+ continue;
+ }
+ if (!\is_array($v)) {
+ unset($files[$k]);
+ } elseif (!isset($v['tmp_name'])) {
+ $files[$k] = $this->normalizeFiles($v);
+ } else {
+ $files[$k] = $this->createUploadedFileFromSpec($v);
+ }
+ }
+
+ return $files;
+ }
+
+ /**
+ * Create and return an UploadedFile instance from a $_FILES specification.
+ *
+ * @param array $value $_FILES struct
+ *
+ * @return UploadedFileInterface|UploadedFileInterface[]
+ */
+ private function createUploadedFileFromSpec(array $value)
+ {
+ if (!is_array($tmpName = $value['tmp_name'])) {
+ $file = is_file($tmpName) ? $this->createStreamFromFile($tmpName, 'r') : $this->createStream();
+
+ return $this->createUploadedFile($file, $value['size'], $value['error'], $value['name'], $value['type']);
+ }
+
+ foreach ($tmpName as $k => $v) {
+ $tmpName[$k] = $this->createUploadedFileFromSpec([
+ 'tmp_name' => $v,
+ 'size' => $value['size'][$k] ?? null,
+ 'error' => $value['error'][$k] ?? null,
+ 'name' => $value['name'][$k] ?? null,
+ 'type' => $value['type'][$k] ?? null,
+ ]);
+ }
+
+ return $tmpName;
+ }
+}
diff --git a/vendor/php-http/discovery/src/Psr17FactoryDiscovery.php b/vendor/php-http/discovery/src/Psr17FactoryDiscovery.php
new file mode 100644
index 000000000..a73c6414b
--- /dev/null
+++ b/vendor/php-http/discovery/src/Psr17FactoryDiscovery.php
@@ -0,0 +1,136 @@
+<?php
+
+namespace Http\Discovery;
+
+use Http\Discovery\Exception\DiscoveryFailedException;
+use Psr\Http\Message\RequestFactoryInterface;
+use Psr\Http\Message\ResponseFactoryInterface;
+use Psr\Http\Message\ServerRequestFactoryInterface;
+use Psr\Http\Message\StreamFactoryInterface;
+use Psr\Http\Message\UploadedFileFactoryInterface;
+use Psr\Http\Message\UriFactoryInterface;
+
+/**
+ * Finds PSR-17 factories.
+ *
+ * @author Tobias Nyholm <[email protected]>
+ */
+final class Psr17FactoryDiscovery extends ClassDiscovery
+{
+ private static function createException($type, Exception $e)
+ {
+ return new \Http\Discovery\Exception\NotFoundException(
+ 'No PSR-17 '.$type.' found. Install a package from this list: https://packagist.org/providers/psr/http-factory-implementation',
+ 0,
+ $e
+ );
+ }
+
+ /**
+ * @return RequestFactoryInterface
+ *
+ * @throws Exception\NotFoundException
+ */
+ public static function findRequestFactory()
+ {
+ try {
+ $messageFactory = static::findOneByType(RequestFactoryInterface::class);
+ } catch (DiscoveryFailedException $e) {
+ throw self::createException('request factory', $e);
+ }
+
+ return static::instantiateClass($messageFactory);
+ }
+
+ /**
+ * @return ResponseFactoryInterface
+ *
+ * @throws Exception\NotFoundException
+ */
+ public static function findResponseFactory()
+ {
+ try {
+ $messageFactory = static::findOneByType(ResponseFactoryInterface::class);
+ } catch (DiscoveryFailedException $e) {
+ throw self::createException('response factory', $e);
+ }
+
+ return static::instantiateClass($messageFactory);
+ }
+
+ /**
+ * @return ServerRequestFactoryInterface
+ *
+ * @throws Exception\NotFoundException
+ */
+ public static function findServerRequestFactory()
+ {
+ try {
+ $messageFactory = static::findOneByType(ServerRequestFactoryInterface::class);
+ } catch (DiscoveryFailedException $e) {
+ throw self::createException('server request factory', $e);
+ }
+
+ return static::instantiateClass($messageFactory);
+ }
+
+ /**
+ * @return StreamFactoryInterface
+ *
+ * @throws Exception\NotFoundException
+ */
+ public static function findStreamFactory()
+ {
+ try {
+ $messageFactory = static::findOneByType(StreamFactoryInterface::class);
+ } catch (DiscoveryFailedException $e) {
+ throw self::createException('stream factory', $e);
+ }
+
+ return static::instantiateClass($messageFactory);
+ }
+
+ /**
+ * @return UploadedFileFactoryInterface
+ *
+ * @throws Exception\NotFoundException
+ */
+ public static function findUploadedFileFactory()
+ {
+ try {
+ $messageFactory = static::findOneByType(UploadedFileFactoryInterface::class);
+ } catch (DiscoveryFailedException $e) {
+ throw self::createException('uploaded file factory', $e);
+ }
+
+ return static::instantiateClass($messageFactory);
+ }
+
+ /**
+ * @return UriFactoryInterface
+ *
+ * @throws Exception\NotFoundException
+ */
+ public static function findUriFactory()
+ {
+ try {
+ $messageFactory = static::findOneByType(UriFactoryInterface::class);
+ } catch (DiscoveryFailedException $e) {
+ throw self::createException('url factory', $e);
+ }
+
+ return static::instantiateClass($messageFactory);
+ }
+
+ /**
+ * @return UriFactoryInterface
+ *
+ * @throws Exception\NotFoundException
+ *
+ * @deprecated This will be removed in 2.0. Consider using the findUriFactory() method.
+ */
+ public static function findUrlFactory()
+ {
+ return static::findUriFactory();
+ }
+}
diff --git a/vendor/php-http/discovery/src/Psr18Client.php b/vendor/php-http/discovery/src/Psr18Client.php
new file mode 100644
index 000000000..c47780ec6
--- /dev/null
+++ b/vendor/php-http/discovery/src/Psr18Client.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace Http\Discovery;
+
+use Psr\Http\Client\ClientInterface;
+use Psr\Http\Message\RequestFactoryInterface;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseFactoryInterface;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestFactoryInterface;
+use Psr\Http\Message\StreamFactoryInterface;
+use Psr\Http\Message\UploadedFileFactoryInterface;
+use Psr\Http\Message\UriFactoryInterface;
+
+/**
+ * A generic PSR-18 and PSR-17 implementation.
+ *
+ * You can create this class with concrete client and factory instances
+ * or let it use discovery to find suitable implementations as needed.
+ *
+ * @author Nicolas Grekas <[email protected]>
+ */
+class Psr18Client extends Psr17Factory implements ClientInterface
+{
+ private $client;
+
+ public function __construct(
+ ClientInterface $client = null,
+ RequestFactoryInterface $requestFactory = null,
+ ResponseFactoryInterface $responseFactory = null,
+ ServerRequestFactoryInterface $serverRequestFactory = null,
+ StreamFactoryInterface $streamFactory = null,
+ UploadedFileFactoryInterface $uploadedFileFactory = null,
+ UriFactoryInterface $uriFactory = null
+ ) {
+ parent::__construct($requestFactory, $responseFactory, $serverRequestFactory, $streamFactory, $uploadedFileFactory, $uriFactory);
+
+ $this->client = $client ?? Psr18ClientDiscovery::find();
+ }
+
+ public function sendRequest(RequestInterface $request): ResponseInterface
+ {
+ return $this->client->sendRequest($request);
+ }
+}
diff --git a/vendor/php-http/discovery/src/Psr18ClientDiscovery.php b/vendor/php-http/discovery/src/Psr18ClientDiscovery.php
new file mode 100644
index 000000000..dfd2dd1e7
--- /dev/null
+++ b/vendor/php-http/discovery/src/Psr18ClientDiscovery.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace Http\Discovery;
+
+use Http\Discovery\Exception\DiscoveryFailedException;
+use Psr\Http\Client\ClientInterface;
+
+/**
+ * Finds a PSR-18 HTTP Client.
+ *
+ * @author Tobias Nyholm <[email protected]>
+ */
+final class Psr18ClientDiscovery extends ClassDiscovery
+{
+ /**
+ * Finds a PSR-18 HTTP Client.
+ *
+ * @return ClientInterface
+ *
+ * @throws Exception\NotFoundException
+ */
+ public static function find()
+ {
+ try {
+ $client = static::findOneByType(ClientInterface::class);
+ } catch (DiscoveryFailedException $e) {
+ throw new \Http\Discovery\Exception\NotFoundException('No PSR-18 clients found. Make sure to install a package providing "psr/http-client-implementation". Example: "php-http/guzzle7-adapter".', 0, $e);
+ }
+
+ return static::instantiateClass($client);
+ }
+}
diff --git a/vendor/php-http/discovery/src/Strategy/CommonClassesStrategy.php b/vendor/php-http/discovery/src/Strategy/CommonClassesStrategy.php
new file mode 100644
index 000000000..ae0b0d842
--- /dev/null
+++ b/vendor/php-http/discovery/src/Strategy/CommonClassesStrategy.php
@@ -0,0 +1,180 @@
+<?php
+
+namespace Http\Discovery\Strategy;
+
+use GuzzleHttp\Client as GuzzleHttp;
+use GuzzleHttp\Promise\Promise;
+use GuzzleHttp\Psr7\Request as GuzzleRequest;
+use Http\Adapter\Artax\Client as Artax;
+use Http\Adapter\Buzz\Client as Buzz;
+use Http\Adapter\Cake\Client as Cake;
+use Http\Adapter\Guzzle5\Client as Guzzle5;
+use Http\Adapter\Guzzle6\Client as Guzzle6;
+use Http\Adapter\Guzzle7\Client as Guzzle7;
+use Http\Adapter\React\Client as React;
+use Http\Client\Curl\Client as Curl;
+use Http\Client\HttpAsyncClient;
+use Http\Client\HttpClient;
+use Http\Client\Socket\Client as Socket;
+use Http\Discovery\ClassDiscovery;
+use Http\Discovery\Exception\NotFoundException;
+use Http\Discovery\Psr17FactoryDiscovery;
+use Http\Message\MessageFactory;
+use Http\Message\MessageFactory\DiactorosMessageFactory;
+use Http\Message\MessageFactory\GuzzleMessageFactory;
+use Http\Message\MessageFactory\SlimMessageFactory;
+use Http\Message\StreamFactory;
+use Http\Message\StreamFactory\DiactorosStreamFactory;
+use Http\Message\StreamFactory\GuzzleStreamFactory;
+use Http\Message\StreamFactory\SlimStreamFactory;
+use Http\Message\UriFactory;
+use Http\Message\UriFactory\DiactorosUriFactory;
+use Http\Message\UriFactory\GuzzleUriFactory;
+use Http\Message\UriFactory\SlimUriFactory;
+use Laminas\Diactoros\Request as DiactorosRequest;
+use Nyholm\Psr7\Factory\HttplugFactory as NyholmHttplugFactory;
+use Psr\Http\Client\ClientInterface as Psr18Client;
+use Psr\Http\Message\RequestFactoryInterface as Psr17RequestFactory;
+use Slim\Http\Request as SlimRequest;
+use Symfony\Component\HttpClient\HttplugClient as SymfonyHttplug;
+use Symfony\Component\HttpClient\Psr18Client as SymfonyPsr18;
+
+/**
+ * @internal
+ *
+ * @author Tobias Nyholm <[email protected]>
+ *
+ * Don't miss updating src/Composer/Plugin.php when adding a new supported class.
+ */
+final class CommonClassesStrategy implements DiscoveryStrategy
+{
+ /**
+ * @var array
+ */
+ private static $classes = [
+ MessageFactory::class => [
+ ['class' => NyholmHttplugFactory::class, 'condition' => [NyholmHttplugFactory::class]],
+ ['class' => GuzzleMessageFactory::class, 'condition' => [GuzzleRequest::class, GuzzleMessageFactory::class]],
+ ['class' => DiactorosMessageFactory::class, 'condition' => [DiactorosRequest::class, DiactorosMessageFactory::class]],
+ ['class' => SlimMessageFactory::class, 'condition' => [SlimRequest::class, SlimMessageFactory::class]],
+ ],
+ StreamFactory::class => [
+ ['class' => NyholmHttplugFactory::class, 'condition' => [NyholmHttplugFactory::class]],
+ ['class' => GuzzleStreamFactory::class, 'condition' => [GuzzleRequest::class, GuzzleStreamFactory::class]],
+ ['class' => DiactorosStreamFactory::class, 'condition' => [DiactorosRequest::class, DiactorosStreamFactory::class]],
+ ['class' => SlimStreamFactory::class, 'condition' => [SlimRequest::class, SlimStreamFactory::class]],
+ ],
+ UriFactory::class => [
+ ['class' => NyholmHttplugFactory::class, 'condition' => [NyholmHttplugFactory::class]],
+ ['class' => GuzzleUriFactory::class, 'condition' => [GuzzleRequest::class, GuzzleUriFactory::class]],
+ ['class' => DiactorosUriFactory::class, 'condition' => [DiactorosRequest::class, DiactorosUriFactory::class]],
+ ['class' => SlimUriFactory::class, 'condition' => [SlimRequest::class, SlimUriFactory::class]],
+ ],
+ HttpAsyncClient::class => [
+ ['class' => SymfonyHttplug::class, 'condition' => [SymfonyHttplug::class, Promise::class, [self::class, 'isPsr17FactoryInstalled']]],
+ ['class' => Guzzle7::class, 'condition' => Guzzle7::class],
+ ['class' => Guzzle6::class, 'condition' => Guzzle6::class],
+ ['class' => Curl::class, 'condition' => Curl::class],
+ ['class' => React::class, 'condition' => React::class],
+ ],
+ HttpClient::class => [
+ ['class' => SymfonyHttplug::class, 'condition' => [SymfonyHttplug::class, [self::class, 'isPsr17FactoryInstalled']]],
+ ['class' => Guzzle7::class, 'condition' => Guzzle7::class],
+ ['class' => Guzzle6::class, 'condition' => Guzzle6::class],
+ ['class' => Guzzle5::class, 'condition' => Guzzle5::class],
+ ['class' => Curl::class, 'condition' => Curl::class],
+ ['class' => Socket::class, 'condition' => Socket::class],
+ ['class' => Buzz::class, 'condition' => Buzz::class],
+ ['class' => React::class, 'condition' => React::class],
+ ['class' => Cake::class, 'condition' => Cake::class],
+ ['class' => Artax::class, 'condition' => Artax::class],
+ [
+ 'class' => [self::class, 'buzzInstantiate'],
+ 'condition' => [\Buzz\Client\FileGetContents::class, \Buzz\Message\ResponseBuilder::class],
+ ],
+ ],
+ Psr18Client::class => [
+ [
+ 'class' => [self::class, 'symfonyPsr18Instantiate'],
+ 'condition' => [SymfonyPsr18::class, Psr17RequestFactory::class],
+ ],
+ [
+ 'class' => GuzzleHttp::class,
+ 'condition' => [self::class, 'isGuzzleImplementingPsr18'],
+ ],
+ [
+ 'class' => [self::class, 'buzzInstantiate'],
+ 'condition' => [\Buzz\Client\FileGetContents::class, \Buzz\Message\ResponseBuilder::class],
+ ],
+ ],
+ ];
+
+ public static function getCandidates($type)
+ {
+ if (Psr18Client::class === $type) {
+ return self::getPsr18Candidates();
+ }
+
+ return self::$classes[$type] ?? [];
+ }
+
+ /**
+ * @return array The return value is always an array with zero or more elements. Each
+ * element is an array with two keys ['class' => string, 'condition' => mixed].
+ */
+ private static function getPsr18Candidates()
+ {
+ $candidates = self::$classes[Psr18Client::class];
+
+ // HTTPlug 2.0 clients implements PSR18Client too.
+ foreach (self::$classes[HttpClient::class] as $c) {
+ if (!is_string($c['class'])) {
+ continue;
+ }
+ try {
+ if (ClassDiscovery::safeClassExists($c['class']) && is_subclass_of($c['class'], Psr18Client::class)) {
+ $candidates[] = $c;
+ }
+ } catch (\Throwable $e) {
+ trigger_error(sprintf('Got exception "%s (%s)" while checking if a PSR-18 Client is available', get_class($e), $e->getMessage()), E_USER_WARNING);
+ }
+ }
+
+ return $candidates;
+ }
+
+ public static function buzzInstantiate()
+ {
+ return new \Buzz\Client\FileGetContents(Psr17FactoryDiscovery::findResponseFactory());
+ }
+
+ public static function symfonyPsr18Instantiate()
+ {
+ return new SymfonyPsr18(null, Psr17FactoryDiscovery::findResponseFactory(), Psr17FactoryDiscovery::findStreamFactory());
+ }
+
+ public static function isGuzzleImplementingPsr18()
+ {
+ return defined('GuzzleHttp\ClientInterface::MAJOR_VERSION');
+ }
+
+ /**
+ * Can be used as a condition.
+ *
+ * @return bool
+ */
+ public static function isPsr17FactoryInstalled()
+ {
+ try {
+ Psr17FactoryDiscovery::findResponseFactory();
+ } catch (NotFoundException $e) {
+ return false;
+ } catch (\Throwable $e) {
+ trigger_error(sprintf('Got exception "%s (%s)" while checking if a PSR-17 ResponseFactory is available', get_class($e), $e->getMessage()), E_USER_WARNING);
+
+ return false;
+ }
+
+ return true;
+ }
+}
diff --git a/vendor/php-http/discovery/src/Strategy/CommonPsr17ClassesStrategy.php b/vendor/php-http/discovery/src/Strategy/CommonPsr17ClassesStrategy.php
new file mode 100644
index 000000000..04cf4baf8
--- /dev/null
+++ b/vendor/php-http/discovery/src/Strategy/CommonPsr17ClassesStrategy.php
@@ -0,0 +1,104 @@
+<?php
+
+namespace Http\Discovery\Strategy;
+
+use Psr\Http\Message\RequestFactoryInterface;
+use Psr\Http\Message\ResponseFactoryInterface;
+use Psr\Http\Message\ServerRequestFactoryInterface;
+use Psr\Http\Message\StreamFactoryInterface;
+use Psr\Http\Message\UploadedFileFactoryInterface;
+use Psr\Http\Message\UriFactoryInterface;
+
+/**
+ * @internal
+ *
+ * @author Tobias Nyholm <[email protected]>
+ *
+ * Don't miss updating src/Composer/Plugin.php when adding a new supported class.
+ */
+final class CommonPsr17ClassesStrategy implements DiscoveryStrategy
+{
+ /**
+ * @var array
+ */
+ private static $classes = [
+ RequestFactoryInterface::class => [
+ 'Phalcon\Http\Message\RequestFactory',
+ 'Nyholm\Psr7\Factory\Psr17Factory',
+ 'GuzzleHttp\Psr7\HttpFactory',
+ 'Http\Factory\Diactoros\RequestFactory',
+ 'Http\Factory\Guzzle\RequestFactory',
+ 'Http\Factory\Slim\RequestFactory',
+ 'Laminas\Diactoros\RequestFactory',
+ 'Slim\Psr7\Factory\RequestFactory',
+ 'HttpSoft\Message\RequestFactory',
+ ],
+ ResponseFactoryInterface::class => [
+ 'Phalcon\Http\Message\ResponseFactory',
+ 'Nyholm\Psr7\Factory\Psr17Factory',
+ 'GuzzleHttp\Psr7\HttpFactory',
+ 'Http\Factory\Diactoros\ResponseFactory',
+ 'Http\Factory\Guzzle\ResponseFactory',
+ 'Http\Factory\Slim\ResponseFactory',
+ 'Laminas\Diactoros\ResponseFactory',
+ 'Slim\Psr7\Factory\ResponseFactory',
+ 'HttpSoft\Message\ResponseFactory',
+ ],
+ ServerRequestFactoryInterface::class => [
+ 'Phalcon\Http\Message\ServerRequestFactory',
+ 'Nyholm\Psr7\Factory\Psr17Factory',
+ 'GuzzleHttp\Psr7\HttpFactory',
+ 'Http\Factory\Diactoros\ServerRequestFactory',
+ 'Http\Factory\Guzzle\ServerRequestFactory',
+ 'Http\Factory\Slim\ServerRequestFactory',
+ 'Laminas\Diactoros\ServerRequestFactory',
+ 'Slim\Psr7\Factory\ServerRequestFactory',
+ 'HttpSoft\Message\ServerRequestFactory',
+ ],
+ StreamFactoryInterface::class => [
+ 'Phalcon\Http\Message\StreamFactory',
+ 'Nyholm\Psr7\Factory\Psr17Factory',
+ 'GuzzleHttp\Psr7\HttpFactory',
+ 'Http\Factory\Diactoros\StreamFactory',
+ 'Http\Factory\Guzzle\StreamFactory',
+ 'Http\Factory\Slim\StreamFactory',
+ 'Laminas\Diactoros\StreamFactory',
+ 'Slim\Psr7\Factory\StreamFactory',
+ 'HttpSoft\Message\StreamFactory',
+ ],
+ UploadedFileFactoryInterface::class => [
+ 'Phalcon\Http\Message\UploadedFileFactory',
+ 'Nyholm\Psr7\Factory\Psr17Factory',
+ 'GuzzleHttp\Psr7\HttpFactory',
+ 'Http\Factory\Diactoros\UploadedFileFactory',
+ 'Http\Factory\Guzzle\UploadedFileFactory',
+ 'Http\Factory\Slim\UploadedFileFactory',
+ 'Laminas\Diactoros\UploadedFileFactory',
+ 'Slim\Psr7\Factory\UploadedFileFactory',
+ 'HttpSoft\Message\UploadedFileFactory',
+ ],
+ UriFactoryInterface::class => [
+ 'Phalcon\Http\Message\UriFactory',
+ 'Nyholm\Psr7\Factory\Psr17Factory',
+ 'GuzzleHttp\Psr7\HttpFactory',
+ 'Http\Factory\Diactoros\UriFactory',
+ 'Http\Factory\Guzzle\UriFactory',
+ 'Http\Factory\Slim\UriFactory',
+ 'Laminas\Diactoros\UriFactory',
+ 'Slim\Psr7\Factory\UriFactory',
+ 'HttpSoft\Message\UriFactory',
+ ],
+ ];
+
+ public static function getCandidates($type)
+ {
+ $candidates = [];
+ if (isset(self::$classes[$type])) {
+ foreach (self::$classes[$type] as $class) {
+ $candidates[] = ['class' => $class, 'condition' => [$class]];
+ }
+ }
+
+ return $candidates;
+ }
+}
diff --git a/vendor/php-http/discovery/src/Strategy/DiscoveryStrategy.php b/vendor/php-http/discovery/src/Strategy/DiscoveryStrategy.php
new file mode 100644
index 000000000..1eadb145b
--- /dev/null
+++ b/vendor/php-http/discovery/src/Strategy/DiscoveryStrategy.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace Http\Discovery\Strategy;
+
+use Http\Discovery\Exception\StrategyUnavailableException;
+
+/**
+ * @author Tobias Nyholm <[email protected]>
+ */
+interface DiscoveryStrategy
+{
+ /**
+ * Find a resource of a specific type.
+ *
+ * @param string $type
+ *
+ * @return array The return value is always an array with zero or more elements. Each
+ * element is an array with two keys ['class' => string, 'condition' => mixed].
+ *
+ * @throws StrategyUnavailableException if we cannot use this strategy
+ */
+ public static function getCandidates($type);
+}
diff --git a/vendor/php-http/discovery/src/Strategy/MockClientStrategy.php b/vendor/php-http/discovery/src/Strategy/MockClientStrategy.php
new file mode 100644
index 000000000..77b9d276f
--- /dev/null
+++ b/vendor/php-http/discovery/src/Strategy/MockClientStrategy.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace Http\Discovery\Strategy;
+
+use Http\Client\HttpAsyncClient;
+use Http\Client\HttpClient;
+use Http\Mock\Client as Mock;
+
+/**
+ * Find the Mock client.
+ *
+ * @author Sam Rapaport <[email protected]>
+ */
+final class MockClientStrategy implements DiscoveryStrategy
+{
+ public static function getCandidates($type)
+ {
+ if (is_a(HttpClient::class, $type, true) || is_a(HttpAsyncClient::class, $type, true)) {
+ return [['class' => Mock::class, 'condition' => Mock::class]];
+ }
+
+ return [];
+ }
+}
diff --git a/vendor/php-http/discovery/src/Strategy/PuliBetaStrategy.php b/vendor/php-http/discovery/src/Strategy/PuliBetaStrategy.php
new file mode 100644
index 000000000..74b78b83f
--- /dev/null
+++ b/vendor/php-http/discovery/src/Strategy/PuliBetaStrategy.php
@@ -0,0 +1,90 @@
+<?php
+
+namespace Http\Discovery\Strategy;
+
+use Http\Discovery\ClassDiscovery;
+use Http\Discovery\Exception\PuliUnavailableException;
+use Puli\Discovery\Api\Discovery;
+use Puli\GeneratedPuliFactory;
+
+/**
+ * Find candidates using Puli.
+ *
+ * @internal
+ *
+ * @final
+ *
+ * @author David de Boer <[email protected]>
+ * @author Márk Sági-Kazár <[email protected]>
+ */
+class PuliBetaStrategy implements DiscoveryStrategy
+{
+ /**
+ * @var GeneratedPuliFactory
+ */
+ protected static $puliFactory;
+
+ /**
+ * @var Discovery
+ */
+ protected static $puliDiscovery;
+
+ /**
+ * @return GeneratedPuliFactory
+ *
+ * @throws PuliUnavailableException
+ */
+ private static function getPuliFactory()
+ {
+ if (null === self::$puliFactory) {
+ if (!defined('PULI_FACTORY_CLASS')) {
+ throw new PuliUnavailableException('Puli Factory is not available');
+ }
+
+ $puliFactoryClass = PULI_FACTORY_CLASS;
+
+ if (!ClassDiscovery::safeClassExists($puliFactoryClass)) {
+ throw new PuliUnavailableException('Puli Factory class does not exist');
+ }
+
+ self::$puliFactory = new $puliFactoryClass();
+ }
+
+ return self::$puliFactory;
+ }
+
+ /**
+ * Returns the Puli discovery layer.
+ *
+ * @return Discovery
+ *
+ * @throws PuliUnavailableException
+ */
+ private static function getPuliDiscovery()
+ {
+ if (!isset(self::$puliDiscovery)) {
+ $factory = self::getPuliFactory();
+ $repository = $factory->createRepository();
+
+ self::$puliDiscovery = $factory->createDiscovery($repository);
+ }
+
+ return self::$puliDiscovery;
+ }
+
+ public static function getCandidates($type)
+ {
+ $returnData = [];
+ $bindings = self::getPuliDiscovery()->findBindings($type);
+
+ foreach ($bindings as $binding) {
+ $condition = true;
+ if ($binding->hasParameterValue('depends')) {
+ $condition = $binding->getParameterValue('depends');
+ }
+ $returnData[] = ['class' => $binding->getClassName(), 'condition' => $condition];
+ }
+
+ return $returnData;
+ }
+}
diff --git a/vendor/php-http/discovery/src/StreamFactoryDiscovery.php b/vendor/php-http/discovery/src/StreamFactoryDiscovery.php
new file mode 100644
index 000000000..e11c49ae2
--- /dev/null
+++ b/vendor/php-http/discovery/src/StreamFactoryDiscovery.php
@@ -0,0 +1,34 @@
+<?php
+
+namespace Http\Discovery;
+
+use Http\Discovery\Exception\DiscoveryFailedException;
+use Http\Message\StreamFactory;
+
+/**
+ * Finds a Stream Factory.
+ *
+ * @author Михаил Красильников <[email protected]>
+ *
+ * @deprecated This will be removed in 2.0. Consider using Psr17FactoryDiscovery.
+ */
+final class StreamFactoryDiscovery extends ClassDiscovery
+{
+ /**
+ * Finds a Stream Factory.
+ *
+ * @return StreamFactory
+ *
+ * @throws Exception\NotFoundException
+ */
+ public static function find()
+ {
+ try {
+ $streamFactory = static::findOneByType(StreamFactory::class);
+ } catch (DiscoveryFailedException $e) {
+ throw new NotFoundException('No stream factories found. To use Guzzle, Diactoros or Slim Framework factories install php-http/message and the chosen message implementation.', 0, $e);
+ }
+
+ return static::instantiateClass($streamFactory);
+ }
+}
diff --git a/vendor/php-http/discovery/src/UriFactoryDiscovery.php b/vendor/php-http/discovery/src/UriFactoryDiscovery.php
new file mode 100644
index 000000000..db3add206
--- /dev/null
+++ b/vendor/php-http/discovery/src/UriFactoryDiscovery.php
@@ -0,0 +1,34 @@
+<?php
+
+namespace Http\Discovery;
+
+use Http\Discovery\Exception\DiscoveryFailedException;
+use Http\Message\UriFactory;
+
+/**
+ * Finds a URI Factory.
+ *
+ * @author David de Boer <[email protected]>
+ *
+ * @deprecated This will be removed in 2.0. Consider using Psr17FactoryDiscovery.
+ */
+final class UriFactoryDiscovery extends ClassDiscovery
+{
+ /**
+ * Finds a URI Factory.
+ *
+ * @return UriFactory
+ *
+ * @throws Exception\NotFoundException
+ */
+ public static function find()
+ {
+ try {
+ $uriFactory = static::findOneByType(UriFactory::class);
+ } catch (DiscoveryFailedException $e) {
+ throw new NotFoundException('No uri factories found. To use Guzzle, Diactoros or Slim Framework factories install php-http/message and the chosen message implementation.', 0, $e);
+ }
+
+ return static::instantiateClass($uriFactory);
+ }
+}