vendor/symfony/symfony/src/Symfony/Component/Form/Extension/DataCollector/FormDataCollector.php line 242

Open in your IDE?
  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\Extension\DataCollector;
  14. use Symfony\Component\Form\FormInterface;
  15. use Symfony\Component\Form\FormView;
  16. use Symfony\Component\HttpFoundation\Request;
  17. use Symfony\Component\HttpFoundation\Response;
  18. use Symfony\Component\HttpKernel\DataCollector\DataCollector;
  19. use Symfony\Component\Validator\ConstraintViolationInterface;
  20. use Symfony\Component\VarDumper\Caster\Caster;
  21. use Symfony\Component\VarDumper\Caster\ClassStub;
  22. use Symfony\Component\VarDumper\Caster\StubCaster;
  23. use Symfony\Component\VarDumper\Cloner\Stub;
  25. /**
  26.  * Data collector for {@link FormInterface} instances.
  27.  *
  28.  * @author Robert Schönthal <robert.schoenthal@gmail.com>
  29.  * @author Bernhard Schussek <bschussek@gmail.com>
  30.  */
  31. class FormDataCollector extends DataCollector implements FormDataCollectorInterface
  32. {
  33.     private $dataExtractor;
  35.     /**
  36.      * Stores the collected data per {@link FormInterface} instance.
  37.      *
  38.      * Uses the hashes of the forms as keys. This is preferable over using
  39.      * {@link \SplObjectStorage}, because in this way no references are kept
  40.      * to the {@link FormInterface} instances.
  41.      *
  42.      * @var array
  43.      */
  44.     private $dataByForm;
  46.     /**
  47.      * Stores the collected data per {@link FormView} instance.
  48.      *
  49.      * Uses the hashes of the views as keys. This is preferable over using
  50.      * {@link \SplObjectStorage}, because in this way no references are kept
  51.      * to the {@link FormView} instances.
  52.      *
  53.      * @var array
  54.      */
  55.     private $dataByView;
  57.     /**
  58.      * Connects {@link FormView} with {@link FormInterface} instances.
  59.      *
  60.      * Uses the hashes of the views as keys and the hashes of the forms as
  61.      * values. This is preferable over storing the objects directly, because
  62.      * this way they can safely be discarded by the GC.
  63.      *
  64.      * @var array
  65.      */
  66.     private $formsByView;
  68.     private $hasVarDumper;
  70.     public function __construct(FormDataExtractorInterface $dataExtractor)
  71.     {
  72.         $this->dataExtractor = $dataExtractor;
  73.         $this->hasVarDumper = class_exists(ClassStub::class);
  75.         $this->reset();
  76.     }
  78.     /**
  79.      * Does nothing. The data is collected during the form event listeners.
  80.      */
  81.     public function collect(Request $request, Response $response, \Exception $exception = null)
  82.     {
  83.     }
  85.     public function reset()
  86.     {
  87.         $this->data = [
  88.             'forms' => [],
  89.             'forms_by_hash' => [],
  90.             'nb_errors' => 0,
  91.         ];
  92.     }
  94.     /**
  95.      * {@inheritdoc}
  96.      */
  97.     public function associateFormWithView(FormInterface $form, FormView $view)
  98.     {
  99.         $this->formsByView[spl_object_hash($view)] = spl_object_hash($form);
  100.     }
  102.     /**
  103.      * {@inheritdoc}
  104.      */
  105.     public function collectConfiguration(FormInterface $form)
  106.     {
  107.         $hash = spl_object_hash($form);
  109.         if (!isset($this->dataByForm[$hash])) {
  110.             $this->dataByForm[$hash] = [];
  111.         }
  113.         $this->dataByForm[$hash] = array_replace(
  114.             $this->dataByForm[$hash],
  115.             $this->dataExtractor->extractConfiguration($form)
  116.         );
  118.         foreach ($form as $child) {
  119.             $this->collectConfiguration($child);
  120.         }
  121.     }
  123.     /**
  124.      * {@inheritdoc}
  125.      */
  126.     public function collectDefaultData(FormInterface $form)
  127.     {
  128.         $hash = spl_object_hash($form);
  130.         if (!isset($this->dataByForm[$hash])) {
  131.             // field was created by form event
  132.             $this->collectConfiguration($form);
  133.         }
  135.         $this->dataByForm[$hash] = array_replace(
  136.             $this->dataByForm[$hash],
  137.             $this->dataExtractor->extractDefaultData($form)
  138.         );
  140.         foreach ($form as $child) {
  141.             $this->collectDefaultData($child);
  142.         }
  143.     }
  145.     /**
  146.      * {@inheritdoc}
  147.      */
  148.     public function collectSubmittedData(FormInterface $form)
  149.     {
  150.         $hash = spl_object_hash($form);
  152.         if (!isset($this->dataByForm[$hash])) {
  153.             // field was created by form event
  154.             $this->collectConfiguration($form);
  155.             $this->collectDefaultData($form);
  156.         }
  158.         $this->dataByForm[$hash] = array_replace(
  159.             $this->dataByForm[$hash],
  160.             $this->dataExtractor->extractSubmittedData($form)
  161.         );
  163.         // Count errors
  164.         if (isset($this->dataByForm[$hash]['errors'])) {
  165.             $this->data['nb_errors'] += \count($this->dataByForm[$hash]['errors']);
  166.         }
  168.         foreach ($form as $child) {
  169.             $this->collectSubmittedData($child);
  171.             // Expand current form if there are children with errors
  172.             if (empty($this->dataByForm[$hash]['has_children_error'])) {
  173.                 $childData = $this->dataByForm[spl_object_hash($child)];
  174.                 $this->dataByForm[$hash]['has_children_error'] = !empty($childData['has_children_error']) || !empty($childData['errors']);
  175.             }
  176.         }
  177.     }
  179.     /**
  180.      * {@inheritdoc}
  181.      */
  182.     public function collectViewVariables(FormView $view)
  183.     {
  184.         $hash = spl_object_hash($view);
  186.         if (!isset($this->dataByView[$hash])) {
  187.             $this->dataByView[$hash] = [];
  188.         }
  190.         $this->dataByView[$hash] = array_replace(
  191.             $this->dataByView[$hash],
  192.             $this->dataExtractor->extractViewVariables($view)
  193.         );
  195.         foreach ($view->children as $child) {
  196.             $this->collectViewVariables($child);
  197.         }
  198.     }
  200.     /**
  201.      * {@inheritdoc}
  202.      */
  203.     public function buildPreliminaryFormTree(FormInterface $form)
  204.     {
  205.         $this->data['forms'][$form->getName()] = &$this->recursiveBuildPreliminaryFormTree($form, $this->data['forms_by_hash']);
  206.     }
  208.     /**
  209.      * {@inheritdoc}
  210.      */
  211.     public function buildFinalFormTree(FormInterface $form, FormView $view)
  212.     {
  213.         $this->data['forms'][$form->getName()] = &$this->recursiveBuildFinalFormTree($form, $view, $this->data['forms_by_hash']);
  214.     }
  216.     /**
  217.      * {@inheritdoc}
  218.      */
  219.     public function getName()
  220.     {
  221.         return 'form';
  222.     }
  224.     /**
  225.      * {@inheritdoc}
  226.      */
  227.     public function getData()
  228.     {
  229.         return $this->data;
  230.     }
  232.     public function serialize()
  233.     {
  234.         if ($this->hasVarDumper) {
  235.             foreach ($this->data['forms_by_hash'] as &$form) {
  236.                 if (isset($form['type_class']) && !$form['type_class'] instanceof ClassStub) {
  237.                     $form['type_class'] = new ClassStub($form['type_class']);
  238.                 }
  239.             }
  240.         }
  242.         return serialize($this->cloneVar($this->data));
  243.     }
  245.     /**
  246.      * {@inheritdoc}
  247.      */
  248.     protected function getCasters()
  249.     {
  250.         return parent::getCasters() + [
  251.             \Exception::class => function (\Exception $e, array $a, Stub $s) {
  252.                 foreach (["\0Exception\0previous", "\0Exception\0trace"] as $k) {
  253.                     if (isset($a[$k])) {
  254.                         unset($a[$k]);
  255.                         ++$s->cut;
  256.                     }
  257.                 }
  259.                 return $a;
  260.             },
  261.             FormInterface::class => function (FormInterface $f, array $a) {
  262.                 return [
  263.                     Caster::PREFIX_VIRTUAL.'name' => $f->getName(),
  264.                     Caster::PREFIX_VIRTUAL.'type_class' => new ClassStub(\get_class($f->getConfig()->getType()->getInnerType())),
  265.                 ];
  266.             },
  267.             FormView::class => [StubCaster::class, 'cutInternals'],
  268.             ConstraintViolationInterface::class => function (ConstraintViolationInterface $v, array $a) {
  269.                 return [
  270.                     Caster::PREFIX_VIRTUAL.'root' => $v->getRoot(),
  271.                     Caster::PREFIX_VIRTUAL.'path' => $v->getPropertyPath(),
  272.                     Caster::PREFIX_VIRTUAL.'value' => $v->getInvalidValue(),
  273.                 ];
  274.             },
  275.         ];
  276.     }
  278.     private function &recursiveBuildPreliminaryFormTree(FormInterface $form, array &$outputByHash)
  279.     {
  280.         $hash = spl_object_hash($form);
  282.         $output = &$outputByHash[$hash];
  283.         $output = isset($this->dataByForm[$hash])
  284.             ? $this->dataByForm[$hash]
  285.             : [];
  287.         $output['children'] = [];
  289.         foreach ($form as $name => $child) {
  290.             $output['children'][$name] = &$this->recursiveBuildPreliminaryFormTree($child, $outputByHash);
  291.         }
  293.         return $output;
  294.     }
  296.     private function &recursiveBuildFinalFormTree(FormInterface $form = null, FormView $view, array &$outputByHash)
  297.     {
  298.         $viewHash = spl_object_hash($view);
  299.         $formHash = null;
  301.         if (null !== $form) {
  302.             $formHash = spl_object_hash($form);
  303.         } elseif (isset($this->formsByView[$viewHash])) {
  304.             // The FormInterface instance of the CSRF token is never contained in
  305.             // the FormInterface tree of the form, so we need to get the
  306.             // corresponding FormInterface instance for its view in a different way
  307.             $formHash = $this->formsByView[$viewHash];
  308.         }
  309.         if (null !== $formHash) {
  310.             $output = &$outputByHash[$formHash];
  311.         }
  313.         $output = isset($this->dataByView[$viewHash])
  314.             ? $this->dataByView[$viewHash]
  315.             : [];
  317.         if (null !== $formHash) {
  318.             $output = array_replace(
  319.                 $output,
  320.                 isset($this->dataByForm[$formHash])
  321.                     ? $this->dataByForm[$formHash]
  322.                     : []
  323.             );
  324.         }
  326.         $output['children'] = [];
  328.         foreach ($view->children as $name => $childView) {
  329.             // The CSRF token, for example, is never added to the form tree.
  330.             // It is only present in the view.
  331.             $childForm = null !== $form && $form->has($name)
  332.                 ? $form->get($name)
  333.                 : null;
  335.             $output['children'][$name] = &$this->recursiveBuildFinalFormTree($childForm, $childView, $outputByHash);
  336.         }
  338.         return $output;
  339.     }
  340. }