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, \Stringable
  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. }