Adding the ArgumentResolver component

Author: chalasr

src/Symfony/Component/ArgumentResolver/.gitattributes

@@ -0,0 +1,3 @@
+/Tests export-ignore
+/phpunit.xml.dist export-ignore
+/.git* export-ignore

src/Symfony/Component/ArgumentResolver/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,3 @@
+vendor/
+composer.lock
+phpunit.xml

src/Symfony/Component/ArgumentResolver/.github/workflows/close-pull-request.yml

@@ -0,0 +1,146 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ArgumentResolver\ArgumentMetadata;
+
+/**
+ * Responsible for storing metadata of an argument.
+ *
+ * @author Iltar van der Berg <[email protected]>
+ *
+ * @final
+ */
+class ArgumentMetadata
+{
+    public const IS_INSTANCEOF = 2;
+
+    /**
+     * @param object[] $attributes
+     */
+    public function __construct(
+        private string $name,
+        private ?string $type,
+        private bool $isVariadic,
+        private bool $hasDefaultValue,
+        private mixed $defaultValue,
+        private bool $isNullable = false,
+        private array $attributes = [],
+        private string $controllerName = 'n/a',
+    ) {
+        $this->isNullable = $isNullable || null === $type || ($hasDefaultValue && null === $defaultValue);
+    }
+
+    /**
+     * Returns the name as given in PHP, $foo would yield "foo".
+     */
+    public function getName(): string
+    {
+        return $this->name;
+    }
+
+    /**
+     * Returns the type of the argument.
+     *
+     * The type is the PHP class in 5.5+ and additionally the basic type in PHP 7.0+.
+     */
+    public function getType(): ?string
+    {
+        return $this->type;
+    }
+
+    /**
+     * Returns whether the argument is defined as "...$variadic".
+     */
+    public function isVariadic(): bool
+    {
+        return $this->isVariadic;
+    }
+
+    /**
+     * Returns whether the argument has a default value.
+     *
+     * Implies whether an argument is optional.
+     */
+    public function hasDefaultValue(): bool
+    {
+        return $this->hasDefaultValue;
+    }
+
+    /**
+     * Returns whether the argument accepts null values.
+     */
+    public function isNullable(): bool
+    {
+        return $this->isNullable;
+    }
+
+    /**
+     * Returns the default value of the argument.
+     *
+     * @throws \LogicException if no default value is present; {@see self::hasDefaultValue()}
+     */
+    public function getDefaultValue(): mixed
+    {
+        if (!$this->hasDefaultValue) {
+            throw new \LogicException(\sprintf('Argument $%s does not have a default value. Use "%s::hasDefaultValue()" to avoid this exception.', $this->name, __CLASS__));
+        }
+
+        return $this->defaultValue;
+    }
+
+    /**
+     * @param class-string          $name
+     * @param self::IS_INSTANCEOF|0 $flags
+     *
+     * @return array<object>
+     */
+    public function getAttributes(?string $name = null, int $flags = 0): array
+    {
+        if (!$name) {
+            return $this->attributes;
+        }
+
+        return $this->getAttributesOfType($name, $flags);
+    }
+
+    /**
+     * @template T of object
+     *
+     * @param class-string<T>       $name
+     * @param self::IS_INSTANCEOF|0 $flags
+     *
+     * @return array<T>
+     */
+    public function getAttributesOfType(string $name, int $flags = 0): array
+    {
+        $attributes = [];
+        if ($flags & self::IS_INSTANCEOF) {
+            foreach ($this->attributes as $attribute) {
+                if ($attribute instanceof $name) {
+                    $attributes[] = $attribute;
+                }
+            }
+        } else {
+            foreach ($this->attributes as $attribute) {
+                if ($attribute::class === $name) {
+                    $attributes[] = $attribute;
+                }
+            }
+        }
+
+        return $attributes;
+    }
+
+    public function getControllerName(): string
+    {
+        return $this->controllerName;
+    }
+}

src/Symfony/Component/ArgumentResolver/.gitignore

@@ -0,0 +1,72 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ArgumentResolver\ArgumentMetadata;
+
+/**
+ * Builds {@see ArgumentMetadata} objects based on the given Controller.
+ *
+ * @author Iltar van der Berg <[email protected]>
+ */
+final class ArgumentMetadataFactory implements ArgumentMetadataFactoryInterface
+{
+    public function createArgumentMetadata(string|object|array $callable, ?\ReflectionFunctionAbstract $reflector = null): array
+    {
+        $arguments = [];
+        $reflector ??= new \ReflectionFunction($callable(...));
+        $callableName = $this->getPrettyName($reflector);
+
+        foreach ($reflector->getParameters() as $param) {
+            $attributes = [];
+            foreach ($param->getAttributes() as $reflectionAttribute) {
+                if (class_exists($reflectionAttribute->getName())) {
+                    $attributes[] = $reflectionAttribute->newInstance();
+                }
+            }
+
+            $arguments[] = new ArgumentMetadata($param->getName(), $this->getType($param), $param->isVariadic(), $param->isDefaultValueAvailable(), $param->isDefaultValueAvailable() ? $param->getDefaultValue() : null, $param->allowsNull(), $attributes, $callableName);
+        }
+
+        return $arguments;
+    }
+
+    /**
+     * Returns an associated type to the given parameter if available.
+     */
+    private function getType(\ReflectionParameter $parameter): ?string
+    {
+        if (!$type = $parameter->getType()) {
+            return null;
+        }
+        $name = $type instanceof \ReflectionNamedType ? $type->getName() : (string) $type;
+
+        return match (strtolower($name)) {
+            'self' => $parameter->getDeclaringClass()?->name,
+            'parent' => get_parent_class($parameter->getDeclaringClass()?->name ?? '') ?: null,
+            default => $name,
+        };
+    }
+
+    private function getPrettyName(\ReflectionFunctionAbstract $r): string
+    {
+        $name = $r->name;
+
+        if ($r instanceof \ReflectionMethod) {
+            return $r->class.'::'.$name;
+        }
+
+        if ($r->isAnonymous() || !$class = $r->getClosureCalledClass()) {
+            return $name;
+        }
+
+        return $class->name.'::'.$name;
+    }
+}

src/Symfony/Component/ArgumentResolver/ArgumentMetadata/ArgumentMetadata.php

@@ -0,0 +1,25 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ArgumentResolver\ArgumentMetadata;
+
+/**
+ * Builds method argument data.
+ *
+ * @author Iltar van der Berg <[email protected]>
+ */
+interface ArgumentMetadataFactoryInterface
+{
+    /**
+     * @return ArgumentMetadata[]
+     */
+    public function createArgumentMetadata(string|object|array $callable, ?\ReflectionFunctionAbstract $reflector = null): array;
+}

src/Symfony/Component/ArgumentResolver/ArgumentMetadata/ArgumentMetadataFactory.php

@@ -0,0 +1,29 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ArgumentResolver;
+
+/**
+ * An ArgumentResolverInterface instance knows how to determine the
+ * arguments for a specific function.
+ *
+ * @author Robin Chalas <[email protected]>
+ * @author Fabien Potencier <[email protected]>
+ */
+interface ArgumentResolverInterface
+{
+    /**
+     * Returns the arguments to pass to the callable.
+     *
+     * @throws \RuntimeException When no value could be provided for a required argument
+     */
+    public function getArguments(callable $callable, ?\ReflectionFunctionAbstract $reflector = null): array;
+}

src/Symfony/Component/ArgumentResolver/ArgumentMetadata/ArgumentMetadataFactoryInterface.php

@@ -0,0 +1,13 @@
+CHANGELOG
+=========
+
+6.2
+---
+
+ * Use `SensitiveParameter` attribute to redact sensitive values in back traces
+
+5.3
+---
+
+ * Add the component
+ * Use `bcrypt` as default algorithm in `NativeArgumentResolver`

src/Symfony/Component/ArgumentResolver/ArgumentResolverInterface.php

@@ -0,0 +1,21 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ArgumentResolver\Exception;
+
+/**
+ * Interface for exceptions thrown by the argument-resolver component.
+ *
+ * @author Robin Chalas <[email protected]>
+ */
+interface ExceptionInterface extends \Throwable
+{
+}