vendor/symfony/form/FormErrorIterator.php line 38

  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Form;
  14. use Symfony\Component\Form\Exception\BadMethodCallException;
  15. use Symfony\Component\Form\Exception\InvalidArgumentException;
  16. use Symfony\Component\Form\Exception\LogicException;
  17. use Symfony\Component\Form\Exception\OutOfBoundsException;
  18. use Symfony\Component\Validator\ConstraintViolation;
  20. /**
  21.  * Iterates over the errors of a form.
  22.  *
  23.  * This class supports recursive iteration. In order to iterate recursively,
  24.  * pass a structure of {@link FormError} and {@link FormErrorIterator} objects
  25.  * to the $errors constructor argument.
  26.  *
  27.  * You can also wrap the iterator into a {@link \RecursiveIteratorIterator} to
  28.  * flatten the recursive structure into a flat list of errors.
  29.  *
  30.  * @author Bernhard Schussek <bschussek@gmail.com>
  31.  *
  32.  * @template T of FormError|FormErrorIterator
  33.  *
  34.  * @implements \ArrayAccess<int, T>
  35.  * @implements \RecursiveIterator<int, T>
  36.  * @implements \SeekableIterator<int, T>
  37.  */
  38. class FormErrorIterator implements \RecursiveIterator, \SeekableIterator, \ArrayAccess, \Countable
  39. {
  40.     /**
  41.      * The prefix used for indenting nested error messages.
  42.      */
  43.     public const INDENTATION = '    ';
  45.     private FormInterface $form;
  47.     /**
  48.      * @var list<T>
  49.      */
  50.     private array $errors;
  52.     /**
  53.      * @param list<T> $errors
  54.      *
  55.      * @throws InvalidArgumentException If the errors are invalid
  56.      */
  57.     public function __construct(FormInterface $form, array $errors)
  58.     {
  59.         foreach ($errors as $error) {
  60.             if (!($error instanceof FormError || $error instanceof self)) {
  61.                 throw new InvalidArgumentException(sprintf('The errors must be instances of "Symfony\Component\Form\FormError" or "%s". Got: "%s".', __CLASS__, get_debug_type($error)));
  62.             }
  63.         }
  65.         $this->form = $form;
  66.         $this->errors = $errors;
  67.     }
  69.     /**
  70.      * Returns all iterated error messages as string.
  71.      */
  72.     public function __toString(): string
  73.     {
  74.         $string = '';
  76.         foreach ($this->errors as $error) {
  77.             if ($error instanceof FormError) {
  78.                 $string .= 'ERROR: '.$error->getMessage()."\n";
  79.             } else {
  80.                 /* @var self $error */
  81.                 $string .= $error->getForm()->getName().":\n";
  82.                 $string .= self::indent((string) $error);
  83.             }
  84.         }
  86.         return $string;
  87.     }
  89.     /**
  90.      * Returns the iterated form.
  91.      */
  92.     public function getForm(): FormInterface
  93.     {
  94.         return $this->form;
  95.     }
  97.     /**
  98.      * Returns the current element of the iterator.
  99.      *
  100.      * @return T An error or an iterator containing nested errors
  101.      */
  102.     public function current(): FormError|self
  103.     {
  104.         return current($this->errors);
  105.     }
  107.     /**
  108.      * Advances the iterator to the next position.
  109.      */
  110.     public function next(): void
  111.     {
  112.         next($this->errors);
  113.     }
  115.     /**
  116.      * Returns the current position of the iterator.
  117.      */
  118.     public function key(): int
  119.     {
  120.         return key($this->errors);
  121.     }
  123.     /**
  124.      * Returns whether the iterator's position is valid.
  125.      */
  126.     public function valid(): bool
  127.     {
  128.         return null !== key($this->errors);
  129.     }
  131.     /**
  132.      * Sets the iterator's position to the beginning.
  133.      *
  134.      * This method detects if errors have been added to the form since the
  135.      * construction of the iterator.
  136.      */
  137.     public function rewind(): void
  138.     {
  139.         reset($this->errors);
  140.     }
  142.     /**
  143.      * Returns whether a position exists in the iterator.
  144.      *
  145.      * @param int $position The position
  146.      */
  147.     public function offsetExists(mixed $position): bool
  148.     {
  149.         return isset($this->errors[$position]);
  150.     }
  152.     /**
  153.      * Returns the element at a position in the iterator.
  154.      *
  155.      * @param int $position The position
  156.      *
  157.      * @return T
  158.      *
  159.      * @throws OutOfBoundsException If the given position does not exist
  160.      */
  161.     public function offsetGet(mixed $position): FormError|self
  162.     {
  163.         if (!isset($this->errors[$position])) {
  164.             throw new OutOfBoundsException('The offset '.$position.' does not exist.');
  165.         }
  167.         return $this->errors[$position];
  168.     }
  170.     /**
  171.      * Unsupported method.
  172.      *
  173.      * @throws BadMethodCallException
  174.      */
  175.     public function offsetSet(mixed $position, mixed $value): void
  176.     {
  177.         throw new BadMethodCallException('The iterator doesn\'t support modification of elements.');
  178.     }
  180.     /**
  181.      * Unsupported method.
  182.      *
  183.      * @throws BadMethodCallException
  184.      */
  185.     public function offsetUnset(mixed $position): void
  186.     {
  187.         throw new BadMethodCallException('The iterator doesn\'t support modification of elements.');
  188.     }
  190.     /**
  191.      * Returns whether the current element of the iterator can be recursed
  192.      * into.
  193.      */
  194.     public function hasChildren(): bool
  195.     {
  196.         return current($this->errors) instanceof self;
  197.     }
  199.     public function getChildren(): self
  200.     {
  201.         if (!$this->hasChildren()) {
  202.             throw new LogicException(sprintf('The current element is not iterable. Use "%s" to get the current element.', self::class.'::current()'));
  203.         }
  205.         /** @var self $children */
  206.         $children = current($this->errors);
  208.         return $children;
  209.     }
  211.     /**
  212.      * Returns the number of elements in the iterator.
  213.      *
  214.      * Note that this is not the total number of errors, if the constructor
  215.      * parameter $deep was set to true! In that case, you should wrap the
  216.      * iterator into a {@link \RecursiveIteratorIterator} with the standard mode
  217.      * {@link \RecursiveIteratorIterator::LEAVES_ONLY} and count the result.
  218.      *
  219.      *     $iterator = new \RecursiveIteratorIterator($form->getErrors(true));
  220.      *     $count = count(iterator_to_array($iterator));
  221.      *
  222.      * Alternatively, set the constructor argument $flatten to true as well.
  223.      *
  224.      *     $count = count($form->getErrors(true, true));
  225.      */
  226.     public function count(): int
  227.     {
  228.         return \count($this->errors);
  229.     }
  231.     /**
  232.      * Sets the position of the iterator.
  233.      *
  234.      * @throws OutOfBoundsException If the position is invalid
  235.      */
  236.     public function seek(int $position): void
  237.     {
  238.         if (!isset($this->errors[$position])) {
  239.             throw new OutOfBoundsException('The offset '.$position.' does not exist.');
  240.         }
  242.         reset($this->errors);
  244.         while ($position !== key($this->errors)) {
  245.             next($this->errors);
  246.         }
  247.     }
  249.     /**
  250.      * Creates iterator for errors with specific codes.
  251.      *
  252.      * @param string|string[] $codes The codes to find
  253.      */
  254.     public function findByCodes(string|array $codes): static
  255.     {
  256.         $codes = (array) $codes;
  257.         $errors = [];
  258.         foreach ($this as $error) {
  259.             $cause = $error->getCause();
  260.             if ($cause instanceof ConstraintViolation && \in_array($cause->getCode(), $codes, true)) {
  261.                 $errors[] = $error;
  262.             }
  263.         }
  265.         return new static($this->form, $errors);
  266.     }
  268.     /**
  269.      * Utility function for indenting multi-line strings.
  270.      */
  271.     private static function indent(string $string): string
  272.     {
  273.         return rtrim(self::INDENTATION.str_replace("\n", "\n".self::INDENTATION, $string), ' ');
  274.     }
  275. }